





'''simple docstring'''





from typing import Callable, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


a__			:    Optional[Any]			      =		logging.get_logger(__name__)

a__			:    Union[str, Any]			      =		{
    '''microsoft/prophetnet-large-uncased''': (
        '''https://huggingface.co/microsoft/prophetnet-large-uncased/resolve/main/config.json'''
    ),
}





class UpperCAmelCase_							(   UpperCamelCase_   ):
  __lowerCAmelCase      :	Optional[int]  	=      """prophetnet"""
  __lowerCAmelCase      :	Optional[int]  	=      ["""past_key_values"""]
  __lowerCAmelCase      :	Any  	=      {
      """num_attention_heads""": """num_encoder_attention_heads""",
  }


  def __init__(       self   ,__snake_case = 0.1   ,__snake_case = "gelu"   ,__snake_case = 3_0_5_2_2   ,__snake_case = 1_0_2_4   ,__snake_case = 4_0_9_6   ,__snake_case = 1_2   ,__snake_case = 1_6   ,__snake_case = 4_0_9_6   ,__snake_case = 1_2   ,__snake_case = 1_6   ,__snake_case = 0.1   ,__snake_case = 0.1   ,__snake_case = 5_1_2   ,__snake_case = 0.02   ,__snake_case = True   ,__snake_case = True   ,__snake_case = 0   ,__snake_case = 2   ,__snake_case = 3_2   ,__snake_case = 1_2_8   ,__snake_case = False   ,__snake_case = 0.0   ,__snake_case = True   ,__snake_case = 0   ,__snake_case = 1   ,__snake_case = 2   ,**__snake_case   ,):



       """simple docstring"""





       A_					      =					vocab_size
       A_					      =					hidden_size
       A_					      =					encoder_ffn_dim
       A_					      =					num_encoder_layers
       A_					      =					num_encoder_attention_heads
       A_					      =					decoder_ffn_dim
       A_					      =					num_decoder_layers
       A_					      =					num_decoder_attention_heads
       A_					      =					max_position_embeddings
       A_					      =					init_std  # Normal(0, this parameter)
       A_					      =					activation_function

       # parameters for prophetnet
       A_					      =					ngram
       A_					      =					num_buckets
       A_					      =					relative_max_distance
       A_					      =					disable_ngram_loss
       A_					      =					eps

       # 3 Types of Dropout
       A_					      =					attention_dropout
       A_					      =					activation_dropout
       A_					      =					dropout

       A_					      =					use_cache

       super().__init__(
           pad_token_id=__SCREAMING_SNAKE_CASE   ,bos_token_id=__SCREAMING_SNAKE_CASE   ,eos_token_id=__SCREAMING_SNAKE_CASE   ,is_encoder_decoder=__SCREAMING_SNAKE_CASE   ,add_cross_attention=__SCREAMING_SNAKE_CASE   ,decoder_start_token_id=__SCREAMING_SNAKE_CASE   ,**__SCREAMING_SNAKE_CASE   ,)


  @property
  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       return self.num_encoder_layers + self.num_decoder_layers




  @num_hidden_layers.setter
  def 	__UpperCAmelCase    (       self   ,__snake_case   ):



       """simple docstring"""





       raise NotImplementedError(
           '''This model does not support the setting of `num_hidden_layers`. Please set `num_encoder_layers` and'''
           ''' `num_decoder_layers`.'''   )










import shutil
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from transformers import SpeechaTextTokenizer, is_speech_available
from transformers.models.speech_to_text.tokenization_speech_to_text import VOCAB_FILES_NAMES, save_json
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, require_torchaudio
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_speech_to_text import floats_list


if is_speech_available():
      from transformers import SpeechaTextFeatureExtractor, SpeechaTextProcessor


a__			:    Optional[Any]			      =		get_tests_dir('fixtures/test_sentencepiece.model')





@require_torch
@require_torchaudio
@require_sentencepiece
class UpperCAmelCase_							(   unittest.TestCase   ):


  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       A_					      =					tempfile.mkdtemp()

       A_					      =					['''<s>''', '''<pad>''', '''</s>''', '''<unk>''', '''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']
       A_					      =					dict(zip(__snake_case   ,range(len(__snake_case   )   )   )   )
       A_					      =					Path(self.tmpdirname   )
       save_json(__snake_case   ,save_dir / VOCAB_FILES_NAMES['''vocab_file''']   )
       if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
            copyfile(__snake_case   ,save_dir / VOCAB_FILES_NAMES['''spm_file''']   )

       A_					      =					SpeechaTextTokenizer.from_pretrained(self.tmpdirname   )
       tokenizer.save_pretrained(self.tmpdirname   )

       A_					      =					{
           '''feature_size''': 2_4,
           '''num_mel_bins''': 2_4,
           '''padding_value''': 0.0,
           '''sampling_rate''': 1_6_0_0_0,
           '''return_attention_mask''': False,
           '''do_normalize''': True,
       }
       save_json(__snake_case   ,save_dir / FEATURE_EXTRACTOR_NAME   )


  def 	__UpperCAmelCase    (       self   ,**__snake_case   ):



       """simple docstring"""





       return SpeechaTextTokenizer.from_pretrained(self.tmpdirname   ,**__snake_case   )


  def 	__UpperCAmelCase    (       self   ,**__snake_case   ):



       """simple docstring"""





       return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname   ,**__snake_case   )


  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       shutil.rmtree(self.tmpdirname   )


  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       A_					      =					self.get_tokenizer()
       A_					      =					self.get_feature_extractor()

       A_					      =					SpeechaTextProcessor(tokenizer=__snake_case   ,feature_extractor=__snake_case   )

       processor.save_pretrained(self.tmpdirname   )
       A_					      =					SpeechaTextProcessor.from_pretrained(self.tmpdirname   )

       self.assertEqual(processor.tokenizer.get_vocab()   ,tokenizer.get_vocab()   )
       self.assertIsInstance(processor.tokenizer   ,__snake_case   )

       self.assertEqual(processor.feature_extractor.to_json_string()   ,feature_extractor.to_json_string()   )
       self.assertIsInstance(processor.feature_extractor   ,__snake_case   )


  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       A_					      =					SpeechaTextProcessor(
           tokenizer=self.get_tokenizer()   ,feature_extractor=self.get_feature_extractor()   )
       processor.save_pretrained(self.tmpdirname   )

       A_					      =					self.get_tokenizer(bos_token='''(BOS)'''   ,eos_token='''(EOS)'''   )
       A_					      =					self.get_feature_extractor(do_normalize=__snake_case   ,padding_value=1.0   )

       A_					      =					SpeechaTextProcessor.from_pretrained(
           self.tmpdirname   ,bos_token='''(BOS)'''   ,eos_token='''(EOS)'''   ,do_normalize=__snake_case   ,padding_value=1.0   )

       self.assertEqual(processor.tokenizer.get_vocab()   ,tokenizer_add_kwargs.get_vocab()   )
       self.assertIsInstance(processor.tokenizer   ,__snake_case   )

       self.assertEqual(processor.feature_extractor.to_json_string()   ,feature_extractor_add_kwargs.to_json_string()   )
       self.assertIsInstance(processor.feature_extractor   ,__snake_case   )


  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       A_					      =					self.get_feature_extractor()
       A_					      =					self.get_tokenizer()

       A_					      =					SpeechaTextProcessor(tokenizer=__snake_case   ,feature_extractor=__snake_case   )

       A_					      =					floats_list((3, 1_0_0_0)   )

       A_					      =					feature_extractor(__snake_case   ,return_tensors='''np'''   )
       A_					      =					processor(__snake_case   ,return_tensors='''np'''   )

       for key in input_feat_extract.keys():
            self.assertAlmostEqual(input_feat_extract[key].sum()   ,input_processor[key].sum()   ,delta=1E-2   )


  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       A_					      =					self.get_feature_extractor()
       A_					      =					self.get_tokenizer()

       A_					      =					SpeechaTextProcessor(tokenizer=__snake_case   ,feature_extractor=__snake_case   )

       A_					      =					'''This is a test string'''

       A_					      =					processor(text=__snake_case   )

       A_					      =					tokenizer(__snake_case   )

       for key in encoded_tok.keys():
            self.assertListEqual(encoded_tok[key]   ,encoded_processor[key]   )


  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       A_					      =					self.get_feature_extractor()
       A_					      =					self.get_tokenizer()

       A_					      =					SpeechaTextProcessor(tokenizer=__snake_case   ,feature_extractor=__snake_case   )

       A_					      =					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

       A_					      =					processor.batch_decode(__snake_case   )
       A_					      =					tokenizer.batch_decode(__snake_case   )

       self.assertListEqual(__snake_case   ,__snake_case   )




  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       A_					      =					self.get_feature_extractor()
       A_					      =					self.get_tokenizer()

       A_					      =					SpeechaTextProcessor(tokenizer=__snake_case   ,feature_extractor=__snake_case   )

       self.assertListEqual(
           processor.model_input_names   ,feature_extractor.model_input_names   ,msg='''`processor` and `feature_extractor` model input names do not match'''   ,)



