





"""simple docstring"""






import os
import unittest

from transformers import BatchEncoding
from transformers.models.bert.tokenization_bert import (
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.models.prophetnet.tokenization_prophetnet import VOCAB_FILES_NAMES, ProphetNetTokenizer
from transformers.testing_utils import require_torch, slow

from ...test_tokenization_common import TokenizerTesterMixin




class 					__lowercase      (      _UpperCamelCase ,   unittest.TestCase				):







					'''simple docstring'''




					__lowerCAmelCase	=	ProphetNetTokenizer
					__lowerCAmelCase	=	False







					def 			_lowerCamelCase		(    self  ):
									super().setUp()

									__a			:    List[Any]      							=	[
									    '''[UNK]''',
									    '''[CLS]''',
									    '''[SEP]''',
									    '''[PAD]''',
									    '''[MASK]''',
									    '''want''',
									    '''##want''',
									    '''##ed''',
									    '''wa''',
									    '''un''',
									    '''runn''',
									    '''##ing''',
									    ''',''',
									    '''low''',
									    '''lowest''',
									]
									__a			:    str      							=	os.path.join(self.tmpdirname						,      VOCAB_FILES_NAMES['''vocab_file''']  )
									with open(self.vocab_file						,      '''w'''						,      encoding='''utf-8'''  ) as vocab_writer:
													vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]  )  )







					def 			_lowerCamelCase		(    self						,      _UpperCAmelCase  ):
									__a			:    List[str]      							=	'''UNwant\u00E9d,running'''
									__a			:    List[Any]      							=	'''unwanted, running'''
									return input_text, output_text







					def 			_lowerCamelCase		(    self  ):
									__a			:    Optional[Any]      							=	self.tokenizer_class(self.vocab_file  )

									__a			:    Any      							=	tokenizer.tokenize('''UNwant\u00E9d,running'''  )
									self.assertListEqual(_UpperCAmelCase						,      ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing''']  )
									self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCAmelCase  )						,      [9, 6, 7, 12, 10, 11]  )







					def 			_lowerCamelCase		(    self  ):
									__a			:    Any      							=	BasicTokenizer()

									self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz'''  )						,      ['''ah''', '''\u535A''', '''\u63A8''', '''zz''']  )







					def 			_lowerCamelCase		(    self  ):
									__a			:    Optional[int]      							=	BasicTokenizer(do_lower_case=_UpperCAmelCase  )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''  )						,      ['''hello''', '''!''', '''how''', '''are''', '''you''', '''?''']  )
									self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''  )						,      ['''hello''']  )







					def 			_lowerCamelCase		(    self  ):
									__a			:    List[Any]      							=	BasicTokenizer(do_lower_case=_UpperCAmelCase						,      strip_accents=_UpperCAmelCase  )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''  )						,      ['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?''']  )
									self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''  )						,      ['''h\u00E9llo''']  )







					def 			_lowerCamelCase		(    self  ):
									__a			:    Optional[Any]      							=	BasicTokenizer(do_lower_case=_UpperCAmelCase						,      strip_accents=_UpperCAmelCase  )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''  )						,      ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']  )
									self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''  )						,      ['''hello''']  )







					def 			_lowerCamelCase		(    self  ):
									__a			:    int      							=	BasicTokenizer(do_lower_case=_UpperCAmelCase  )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''  )						,      ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']  )
									self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''  )						,      ['''hello''']  )







					def 			_lowerCamelCase		(    self  ):
									__a			:    List[Any]      							=	BasicTokenizer(do_lower_case=_UpperCAmelCase  )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''  )						,      ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']  )







					def 			_lowerCamelCase		(    self  ):
									__a			:    Union[str, Any]      							=	BasicTokenizer(do_lower_case=_UpperCAmelCase						,      strip_accents=_UpperCAmelCase  )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''  )						,      ['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']  )







					def 			_lowerCamelCase		(    self  ):
									__a			:    List[Any]      							=	BasicTokenizer(do_lower_case=_UpperCAmelCase						,      strip_accents=_UpperCAmelCase  )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''  )						,      ['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']  )







					def 			_lowerCamelCase		(    self  ):
									__a			:    Any      							=	BasicTokenizer(do_lower_case=_UpperCAmelCase						,      never_split=['''[UNK]''']  )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU? [UNK]'''  )						,      ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]''']  )







					def 			_lowerCamelCase		(    self  ):
									__a			:    Tuple      							=	['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

									__a			:    str      							=	{}
									for i, token in enumerate(_UpperCAmelCase  ):
													__a			:    Tuple      							=	i
									__a			:    Dict      							=	WordpieceTokenizer(vocab=_UpperCAmelCase						,      unk_token='''[UNK]'''  )

									self.assertListEqual(tokenizer.tokenize(''''''  )						,      []  )

									self.assertListEqual(tokenizer.tokenize('''unwanted running'''  )						,      ['''un''', '''##want''', '''##ed''', '''runn''', '''##ing''']  )

									self.assertListEqual(tokenizer.tokenize('''unwantedX running'''  )						,      ['''[UNK]''', '''runn''', '''##ing''']  )







					@require_torch
					def 			_lowerCamelCase		(    self  ):
									__a			:    Union[str, Any]      							=	self.tokenizer_class.from_pretrained('''microsoft/prophetnet-large-uncased'''  )

									__a			:    Tuple      							=	['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
									__a			:    List[Any]      							=	[1037, 2146, 20423, 2005, 7680, 7849, 3989, 1012, 102]
									__a			:    List[str]      							=	tokenizer(_UpperCAmelCase						,      padding=_UpperCAmelCase						,      return_tensors='''pt'''  )
									self.assertIsInstance(_UpperCAmelCase						,      _UpperCAmelCase  )
									__a			:    Dict      							=	list(batch.input_ids.numpy()[0]  )
									self.assertListEqual(_UpperCAmelCase						,      _UpperCAmelCase  )

									self.assertEqual((2, 9)						,      batch.input_ids.shape  )
									self.assertEqual((2, 9)						,      batch.attention_mask.shape  )







					def 			_lowerCamelCase		(    self  ):
									self.assertTrue(_is_whitespace(''' '''  )  )
									self.assertTrue(_is_whitespace('''\t'''  )  )
									self.assertTrue(_is_whitespace('''\r'''  )  )
									self.assertTrue(_is_whitespace('''\n'''  )  )
									self.assertTrue(_is_whitespace('''\u00A0'''  )  )

									self.assertFalse(_is_whitespace('''A'''  )  )
									self.assertFalse(_is_whitespace('''-'''  )  )







					def 			_lowerCamelCase		(    self  ):
									self.assertTrue(_is_control('''\u0005'''  )  )

									self.assertFalse(_is_control('''A'''  )  )
									self.assertFalse(_is_control(''' '''  )  )
									self.assertFalse(_is_control('''\t'''  )  )
									self.assertFalse(_is_control('''\r'''  )  )







					def 			_lowerCamelCase		(    self  ):
									self.assertTrue(_is_punctuation('''-'''  )  )
									self.assertTrue(_is_punctuation('''$'''  )  )
									self.assertTrue(_is_punctuation('''`'''  )  )
									self.assertTrue(_is_punctuation('''.'''  )  )

									self.assertFalse(_is_punctuation('''A'''  )  )
									self.assertFalse(_is_punctuation(''' '''  )  )







					@slow
					def 			_lowerCamelCase		(    self  ):
									__a			:    Tuple      							=	self.tokenizer_class.from_pretrained('''microsoft/prophetnet-large-uncased'''  )

									__a			:    List[Any]      							=	tokenizer.encode('''sequence builders'''						,      add_special_tokens=_UpperCAmelCase  )
									__a			:    Any      							=	tokenizer.encode('''multi-sequence build'''						,      add_special_tokens=_UpperCAmelCase  )

									__a			:    Optional[Any]      							=	tokenizer.build_inputs_with_special_tokens(_UpperCAmelCase  )
									__a			:    List[str]      							=	tokenizer.build_inputs_with_special_tokens(_UpperCAmelCase						,      _UpperCAmelCase  )

									assert encoded_sentence == text + [102]
									assert encoded_pair == text + [102] + text_a + [102]
"""simple docstring"""



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


_UpperCamelCase								=		logging.get_logger(__name__)
class 						__UpperCAmelCase    (__A     ):







			'''simple docstring'''
			_UpperCamelCase  :						Optional[int]					     =				['input_features', 'is_longer']





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







										'''simple docstring'''


										super().__init__(
										    feature_size=snake_case_   ,      sampling_rate=snake_case_   ,      padding_value=snake_case_   ,      return_attention_mask=snake_case_   ,      **snake_case_   ,      )
										A__       :     List[str]								=			top_db
										A__       :     Optional[int]								=			truncation
										A__       :     str								=			padding
										A__       :     str								=			fft_window_size
										A__       :     Any								=			(fft_window_size >> 1) + 1
										A__       :     Optional[Any]								=			hop_length
										A__       :     Any								=			max_length_s
										A__       :     int								=			max_length_s * sampling_rate
										A__       :     Any								=			sampling_rate
										A__       :     List[str]								=			frequency_min
										A__       :     int								=			frequency_max
										A__       :     Tuple								=			mel_filter_bank(
										    num_frequency_bins=self.nb_frequency_bins   ,      num_mel_filters=snake_case_   ,      min_frequency=snake_case_   ,      max_frequency=snake_case_   ,      sampling_rate=snake_case_   ,      norm=snake_case_   ,      mel_scale="""htk"""   ,      )
										A__       :     List[Any]								=			mel_filter_bank(
										    num_frequency_bins=self.nb_frequency_bins   ,      num_mel_filters=snake_case_   ,      min_frequency=snake_case_   ,      max_frequency=snake_case_   ,      sampling_rate=snake_case_   ,      norm="""slaney"""   ,      mel_scale="""slaney"""   ,      )





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     List[Any]								=			copy.deepcopy(self.__dict__							)
										A__       :     int								=			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 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_ = None							):







										'''simple docstring'''


										A__       :     Any								=			spectrogram(
										    snake_case_   ,      window_function(self.fft_window_size   ,      """hann"""							)   ,      frame_length=self.fft_window_size   ,      hop_length=self.hop_length   ,      power=2.0   ,      mel_filters=snake_case_   ,      log_mel="""dB"""   ,      )
										return log_mel_spectrogram.T





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_							):







										'''simple docstring'''


										A__       :     Union[str, Any]								=			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
																	A__       :     Optional[Any]								=			[0]
										if len(ranges[2]							) == 0:
																	# if the audio is too short, we just use the first chunk
																	A__       :     str								=			[0]
										# randomly choose index for each part
										A__       :     int								=			np.random.choice(ranges[0]							)
										A__       :     Dict								=			np.random.choice(ranges[1]							)
										A__       :     Dict								=			np.random.choice(ranges[2]							)

										A__       :     Any								=			mel[idx_front : idx_front + chunk_frames, :]
										A__       :     Optional[int]								=			mel[idx_middle : idx_middle + chunk_frames, :]
										A__       :     Optional[int]								=			mel[idx_back : idx_back + chunk_frames, :]

										A__       :     Dict								=			torch.tensor(mel[None, None, :]							)
										A__       :     Dict								=			torch.nn.functional.interpolate(
										    snake_case_   ,      size=[chunk_frames, 64]   ,      mode="""bilinear"""   ,      align_corners=snake_case_							)
										A__       :     List[Any]								=			mel_shrink[0][0].numpy()
										A__       :     Dict								=			np.stack([mel_shrink, mel_chunk_front, mel_chunk_middle, mel_chunk_back]   ,      axis=0							)
										return mel_fusion





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_							):







										'''simple docstring'''


										if waveform.shape[0] > max_length:
																	if truncation == "rand_trunc":
																								A__       :     int								=			True
																								# random crop to max_length (for compatibility) -> this should be handled by self.pad
																								A__       :     Tuple								=			len(snake_case_							) - max_length
																								A__       :     Any								=			np.random.randint(0   ,      overflow + 1							)
																								A__       :     int								=			waveform[idx : idx + max_length]
																								A__       :     List[str]								=			self._np_extract_fbank_features(snake_case_   ,      self.mel_filters_slaney							)[None, :]
																	elif truncation == "fusion":
																								A__       :     Optional[int]								=			self._np_extract_fbank_features(snake_case_   ,      self.mel_filters							)
																								A__       :     Optional[int]								=			max_length // self.hop_length + 1  # the +1 related to how the spectrogram is computed
																								A__       :     int								=			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.
																															A__       :     Union[str, Any]								=			np.stack([mel, mel, mel, mel]   ,      axis=0							)
																															A__       :     Dict								=			False
																								else:
																															A__       :     List[Any]								=			self._random_mel_fusion(snake_case_   ,      snake_case_   ,      snake_case_							)
																															A__       :     Optional[Any]								=			True
																	else:
																								raise NotImplementedError(F'''data_truncating {truncation} not implemented'''							)

										else:
																	A__       :     Tuple								=			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":
																															A__       :     Union[str, Any]								=			int(max_length / len(snake_case_							)							)
																															A__       :     List[Any]								=			np.stack(np.tile(snake_case_   ,      n_repeat + 1							)							)[:max_length]
																								if padding == "repeatpad":
																															A__       :     List[Any]								=			int(max_length / len(snake_case_							)							)
																															A__       :     Tuple								=			np.stack(np.tile(snake_case_   ,      snake_case_							)							)
																								A__       :     Tuple								=			np.pad(snake_case_   ,      (0, max_length - waveform.shape[0])   ,      mode="""constant"""   ,      constant_values=0							)

																	if truncation == "fusion":
																								A__       :     str								=			self._np_extract_fbank_features(snake_case_   ,      self.mel_filters							)
																								A__       :     List[Any]								=			np.stack([input_mel, input_mel, input_mel, input_mel]   ,      axis=0							)
																	else:
																								A__       :     List[Any]								=			self._np_extract_fbank_features(snake_case_   ,      self.mel_filters_slaney							)[None, :]

										return input_mel, longer





			def __call__(			self   ,      snake_case_   ,      snake_case_ = None   ,      snake_case_ = None   ,      snake_case_ = None   ,      snake_case_ = None   ,      snake_case_ = None   ,      **snake_case_   ,      ):







										'''simple docstring'''


										A__       :     Optional[Any]								=			truncation if truncation is not None else self.truncation
										A__       :     Union[str, Any]								=			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."""							)

										A__       :     List[Any]								=			isinstance(snake_case_   ,      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}'''							)
										A__       :     int								=			is_batched_numpy or (
										    isinstance(snake_case_   ,      (list, tuple)							) and (isinstance(raw_speech[0]   ,      (np.ndarray, tuple, list)							))
										)

										if is_batched:
																	A__       :     Any								=			[np.asarray(snake_case_   ,      dtype=np.floataa							) for speech in raw_speech]
										elif not is_batched and not isinstance(snake_case_   ,      np.ndarray							):
																	A__       :     Any								=			np.asarray(snake_case_   ,      dtype=np.floataa							)
										elif isinstance(snake_case_   ,      np.ndarray							) and raw_speech.dtype is np.dtype(np.floataa							):
																	A__       :     Optional[int]								=			raw_speech.astype(np.floataa							)

										# always return batch
										if not is_batched:
																	A__       :     Union[str, Any]								=			[np.asarray(snake_case_							)]

										# convert to mel spectrogram, truncate and pad if needed.
										A__       :     Optional[Any]								=			[
										    self._get_input_mel(snake_case_   ,      max_length if max_length else self.nb_max_samples   ,      snake_case_   ,      snake_case_							)
										    for waveform in raw_speech
										]

										A__       :     List[str]								=			[]
										A__       :     Optional[Any]								=			[]
										for mel, longer in padded_inputs:
																	input_mel.append(snake_case_							)
																	is_longer.append(snake_case_							)

										if truncation == "fusion" and sum(snake_case_							) == 0:
																	# if no audio is longer than 10s, then randomly select one audio to be longer
																	A__       :     Optional[Any]								=			np.random.randint(0   ,      len(snake_case_							)							)
																	A__       :     str								=			True

										if isinstance(input_mel[0]   ,      snake_case_							):
																	A__       :     Optional[Any]								=			[np.asarray(snake_case_   ,      dtype=np.floataa							) for feature in input_mel]

										# is_longer is a list of bool
										A__       :     Union[str, Any]								=			[[longer] for longer in is_longer]

										A__       :     str								=			{"""input_features""": input_mel, """is_longer""": is_longer}
										A__       :     Optional[int]								=			BatchFeature(snake_case_							)

										if return_tensors is not None:
																	A__       :     Dict								=			input_features.convert_to_tensors(snake_case_							)

										return input_features





