
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


lowercase__							:							List[Any]													=     {
    "auto_factory": ["get_values"],
    "configuration_auto": ["ALL_PRETRAINED_CONFIG_ARCHIVE_MAP", "CONFIG_MAPPING", "MODEL_NAMES_MAPPING", "AutoConfig"],
    "feature_extraction_auto": ["FEATURE_EXTRACTOR_MAPPING", "AutoFeatureExtractor"],
    "image_processing_auto": ["IMAGE_PROCESSOR_MAPPING", "AutoImageProcessor"],
    "processing_auto": ["PROCESSOR_MAPPING", "AutoProcessor"],
    "tokenization_auto": ["TOKENIZER_MAPPING", "AutoTokenizer"],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowercase__							:							Union[str, Any]													=     [
				    "MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING",
				    "MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING",
				    "MODEL_FOR_AUDIO_XVECTOR_MAPPING",
				    "MODEL_FOR_BACKBONE_MAPPING",
				    "MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING",
				    "MODEL_FOR_CAUSAL_LM_MAPPING",
				    "MODEL_FOR_CTC_MAPPING",
				    "MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING",
				    "MODEL_FOR_DEPTH_ESTIMATION_MAPPING",
				    "MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING",
				    "MODEL_FOR_IMAGE_SEGMENTATION_MAPPING",
				    "MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING",
				    "MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING",
				    "MODEL_FOR_MASKED_LM_MAPPING",
				    "MODEL_FOR_MASK_GENERATION_MAPPING",
				    "MODEL_FOR_MULTIPLE_CHOICE_MAPPING",
				    "MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING",
				    "MODEL_FOR_OBJECT_DETECTION_MAPPING",
				    "MODEL_FOR_PRETRAINING_MAPPING",
				    "MODEL_FOR_QUESTION_ANSWERING_MAPPING",
				    "MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING",
				    "MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING",
				    "MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING",
				    "MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING",
				    "MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING",
				    "MODEL_FOR_TEXT_ENCODING_MAPPING",
				    "MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING",
				    "MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING",
				    "MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING",
				    "MODEL_FOR_VISION_2_SEQ_MAPPING",
				    "MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING",
				    "MODEL_MAPPING",
				    "MODEL_WITH_LM_HEAD_MAPPING",
				    "MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING",
				    "MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING",
				    "AutoModel",
				    "AutoBackbone",
				    "AutoModelForAudioClassification",
				    "AutoModelForAudioFrameClassification",
				    "AutoModelForAudioXVector",
				    "AutoModelForCausalLM",
				    "AutoModelForCTC",
				    "AutoModelForDepthEstimation",
				    "AutoModelForImageClassification",
				    "AutoModelForImageSegmentation",
				    "AutoModelForInstanceSegmentation",
				    "AutoModelForMaskGeneration",
				    "AutoModelForTextEncoding",
				    "AutoModelForMaskedImageModeling",
				    "AutoModelForMaskedLM",
				    "AutoModelForMultipleChoice",
				    "AutoModelForNextSentencePrediction",
				    "AutoModelForObjectDetection",
				    "AutoModelForPreTraining",
				    "AutoModelForQuestionAnswering",
				    "AutoModelForSemanticSegmentation",
				    "AutoModelForSeq2SeqLM",
				    "AutoModelForSequenceClassification",
				    "AutoModelForSpeechSeq2Seq",
				    "AutoModelForTableQuestionAnswering",
				    "AutoModelForTokenClassification",
				    "AutoModelForUniversalSegmentation",
				    "AutoModelForVideoClassification",
				    "AutoModelForVision2Seq",
				    "AutoModelForVisualQuestionAnswering",
				    "AutoModelForDocumentQuestionAnswering",
				    "AutoModelWithLMHead",
				    "AutoModelForZeroShotImageClassification",
				    "AutoModelForZeroShotObjectDetection",
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowercase__							:							Union[str, Any]													=     [
				    "TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING",
				    "TF_MODEL_FOR_CAUSAL_LM_MAPPING",
				    "TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING",
				    "TF_MODEL_FOR_MASK_GENERATION_MAPPING",
				    "TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING",
				    "TF_MODEL_FOR_MASKED_LM_MAPPING",
				    "TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING",
				    "TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING",
				    "TF_MODEL_FOR_PRETRAINING_MAPPING",
				    "TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING",
				    "TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING",
				    "TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING",
				    "TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING",
				    "TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING",
				    "TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING",
				    "TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING",
				    "TF_MODEL_FOR_TEXT_ENCODING_MAPPING",
				    "TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING",
				    "TF_MODEL_FOR_VISION_2_SEQ_MAPPING",
				    "TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING",
				    "TF_MODEL_MAPPING",
				    "TF_MODEL_WITH_LM_HEAD_MAPPING",
				    "TFAutoModel",
				    "TFAutoModelForAudioClassification",
				    "TFAutoModelForCausalLM",
				    "TFAutoModelForImageClassification",
				    "TFAutoModelForMaskedImageModeling",
				    "TFAutoModelForMaskedLM",
				    "TFAutoModelForMaskGeneration",
				    "TFAutoModelForMultipleChoice",
				    "TFAutoModelForNextSentencePrediction",
				    "TFAutoModelForPreTraining",
				    "TFAutoModelForDocumentQuestionAnswering",
				    "TFAutoModelForQuestionAnswering",
				    "TFAutoModelForSemanticSegmentation",
				    "TFAutoModelForSeq2SeqLM",
				    "TFAutoModelForSequenceClassification",
				    "TFAutoModelForSpeechSeq2Seq",
				    "TFAutoModelForTableQuestionAnswering",
				    "TFAutoModelForTextEncoding",
				    "TFAutoModelForTokenClassification",
				    "TFAutoModelForVision2Seq",
				    "TFAutoModelForZeroShotImageClassification",
				    "TFAutoModelWithLMHead",
				]

try:
				if not is_flax_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowercase__							:							Any													=     [
				    "FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING",
				    "FLAX_MODEL_FOR_CAUSAL_LM_MAPPING",
				    "FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING",
				    "FLAX_MODEL_FOR_MASKED_LM_MAPPING",
				    "FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING",
				    "FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING",
				    "FLAX_MODEL_FOR_PRETRAINING_MAPPING",
				    "FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING",
				    "FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING",
				    "FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING",
				    "FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING",
				    "FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING",
				    "FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING",
				    "FLAX_MODEL_MAPPING",
				    "FlaxAutoModel",
				    "FlaxAutoModelForCausalLM",
				    "FlaxAutoModelForImageClassification",
				    "FlaxAutoModelForMaskedLM",
				    "FlaxAutoModelForMultipleChoice",
				    "FlaxAutoModelForNextSentencePrediction",
				    "FlaxAutoModelForPreTraining",
				    "FlaxAutoModelForQuestionAnswering",
				    "FlaxAutoModelForSeq2SeqLM",
				    "FlaxAutoModelForSequenceClassification",
				    "FlaxAutoModelForSpeechSeq2Seq",
				    "FlaxAutoModelForTokenClassification",
				    "FlaxAutoModelForVision2Seq",
				]


if TYPE_CHECKING:
				from .auto_factory import get_values
				from .configuration_auto import ALL_PRETRAINED_CONFIG_ARCHIVE_MAP, CONFIG_MAPPING, MODEL_NAMES_MAPPING, AutoConfig
				from .feature_extraction_auto import FEATURE_EXTRACTOR_MAPPING, AutoFeatureExtractor
				from .image_processing_auto import IMAGE_PROCESSOR_MAPPING, AutoImageProcessor
				from .processing_auto import PROCESSOR_MAPPING, AutoProcessor
				from .tokenization_auto import TOKENIZER_MAPPING, AutoTokenizer

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_auto import (
								    MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
								    MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING,
								    MODEL_FOR_AUDIO_XVECTOR_MAPPING,
								    MODEL_FOR_BACKBONE_MAPPING,
								    MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING,
								    MODEL_FOR_CAUSAL_LM_MAPPING,
								    MODEL_FOR_CTC_MAPPING,
								    MODEL_FOR_DEPTH_ESTIMATION_MAPPING,
								    MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
								    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
								    MODEL_FOR_IMAGE_SEGMENTATION_MAPPING,
								    MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING,
								    MODEL_FOR_MASK_GENERATION_MAPPING,
								    MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
								    MODEL_FOR_MASKED_LM_MAPPING,
								    MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
								    MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
								    MODEL_FOR_OBJECT_DETECTION_MAPPING,
								    MODEL_FOR_PRETRAINING_MAPPING,
								    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
								    MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
								    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
								    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
								    MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
								    MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
								    MODEL_FOR_TEXT_ENCODING_MAPPING,
								    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
								    MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING,
								    MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
								    MODEL_FOR_VISION_2_SEQ_MAPPING,
								    MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING,
								    MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
								    MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING,
								    MODEL_MAPPING,
								    MODEL_WITH_LM_HEAD_MAPPING,
								    AutoBackbone,
								    AutoModel,
								    AutoModelForAudioClassification,
								    AutoModelForAudioFrameClassification,
								    AutoModelForAudioXVector,
								    AutoModelForCausalLM,
								    AutoModelForCTC,
								    AutoModelForDepthEstimation,
								    AutoModelForDocumentQuestionAnswering,
								    AutoModelForImageClassification,
								    AutoModelForImageSegmentation,
								    AutoModelForInstanceSegmentation,
								    AutoModelForMaskedImageModeling,
								    AutoModelForMaskedLM,
								    AutoModelForMaskGeneration,
								    AutoModelForMultipleChoice,
								    AutoModelForNextSentencePrediction,
								    AutoModelForObjectDetection,
								    AutoModelForPreTraining,
								    AutoModelForQuestionAnswering,
								    AutoModelForSemanticSegmentation,
								    AutoModelForSeqaSeqLM,
								    AutoModelForSequenceClassification,
								    AutoModelForSpeechSeqaSeq,
								    AutoModelForTableQuestionAnswering,
								    AutoModelForTextEncoding,
								    AutoModelForTokenClassification,
								    AutoModelForUniversalSegmentation,
								    AutoModelForVideoClassification,
								    AutoModelForVisionaSeq,
								    AutoModelForVisualQuestionAnswering,
								    AutoModelForZeroShotImageClassification,
								    AutoModelForZeroShotObjectDetection,
								    AutoModelWithLMHead,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_auto import (
								    TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
								    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
								    TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
								    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
								    TF_MODEL_FOR_MASK_GENERATION_MAPPING,
								    TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
								    TF_MODEL_FOR_MASKED_LM_MAPPING,
								    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
								    TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
								    TF_MODEL_FOR_PRETRAINING_MAPPING,
								    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
								    TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
								    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
								    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
								    TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
								    TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
								    TF_MODEL_FOR_TEXT_ENCODING_MAPPING,
								    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
								    TF_MODEL_FOR_VISION_2_SEQ_MAPPING,
								    TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
								    TF_MODEL_MAPPING,
								    TF_MODEL_WITH_LM_HEAD_MAPPING,
								    TFAutoModel,
								    TFAutoModelForAudioClassification,
								    TFAutoModelForCausalLM,
								    TFAutoModelForDocumentQuestionAnswering,
								    TFAutoModelForImageClassification,
								    TFAutoModelForMaskedImageModeling,
								    TFAutoModelForMaskedLM,
								    TFAutoModelForMaskGeneration,
								    TFAutoModelForMultipleChoice,
								    TFAutoModelForNextSentencePrediction,
								    TFAutoModelForPreTraining,
								    TFAutoModelForQuestionAnswering,
								    TFAutoModelForSemanticSegmentation,
								    TFAutoModelForSeqaSeqLM,
								    TFAutoModelForSequenceClassification,
								    TFAutoModelForSpeechSeqaSeq,
								    TFAutoModelForTableQuestionAnswering,
								    TFAutoModelForTextEncoding,
								    TFAutoModelForTokenClassification,
								    TFAutoModelForVisionaSeq,
								    TFAutoModelForZeroShotImageClassification,
								    TFAutoModelWithLMHead,
								)

				try:
								if not is_flax_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_flax_auto import (
								    FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
								    FLAX_MODEL_FOR_CAUSAL_LM_MAPPING,
								    FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
								    FLAX_MODEL_FOR_MASKED_LM_MAPPING,
								    FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
								    FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
								    FLAX_MODEL_FOR_PRETRAINING_MAPPING,
								    FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
								    FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
								    FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
								    FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
								    FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
								    FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING,
								    FLAX_MODEL_MAPPING,
								    FlaxAutoModel,
								    FlaxAutoModelForCausalLM,
								    FlaxAutoModelForImageClassification,
								    FlaxAutoModelForMaskedLM,
								    FlaxAutoModelForMultipleChoice,
								    FlaxAutoModelForNextSentencePrediction,
								    FlaxAutoModelForPreTraining,
								    FlaxAutoModelForQuestionAnswering,
								    FlaxAutoModelForSeqaSeqLM,
								    FlaxAutoModelForSequenceClassification,
								    FlaxAutoModelForSpeechSeqaSeq,
								    FlaxAutoModelForTokenClassification,
								    FlaxAutoModelForVisionaSeq,
								)

else:
				import sys

				lowercase__							:							Dict													=     _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)






import json
import os
import shutil
import tempfile
import unittest

from transformers import is_speech_available, is_torch_available
from transformers.models.speechta import SpeechTaTokenizer
from transformers.testing_utils import get_tests_dir, require_torch
from transformers.utils import FEATURE_EXTRACTOR_NAME


if is_speech_available() and is_torch_available():
				from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor

				from .test_feature_extraction_speechta import floats_list


lowercase__							:							List[Any]													=     get_tests_dir("fixtures/test_sentencepiece_bpe_char.model")






@require_torch
class     SCREAMING_SNAKE_CASE__      (							unittest.TestCase      ):

							"""simple docstring"""






							def       A__						(					self     )->				List[Any]:





													'''simple docstring'''






													__UpperCamelCase       					=     tempfile.mkdtemp()

													__UpperCamelCase       					=     SpeechTaTokenizer(SCREAMING_SNAKE_CASE_     )
													tokenizer.save_pretrained(self.tmpdirname     )

													__UpperCamelCase       					=     {
													    '''feature_size''': 1,
													    '''padding_value''': 0.0,
													    '''sampling_rate''': 16000,
													    '''do_normalize''': False,
													    '''num_mel_bins''': 80,
													    '''hop_length''': 16,
													    '''win_length''': 64,
													    '''win_function''': '''hann_window''',
													    '''fmin''': 80,
													    '''fmax''': 7600,
													    '''mel_floor''': 1E-10,
													    '''reduction_factor''': 2,
													    '''return_attention_mask''': True,
													}

													__UpperCamelCase       					=     os.path.join(self.tmpdirname       ,		SCREAMING_SNAKE_CASE_     )
													with open(self.feature_extraction_file       ,		'''w'''       ,		encoding='''utf-8'''     ) as fp:
																			fp.write(json.dumps(SCREAMING_SNAKE_CASE_     ) + '''\n'''     )



							def       A__						(					self       ,		**SCREAMING_SNAKE_CASE_     )->				Union[str, Any]:





													'''simple docstring'''






													return SpeechTaTokenizer.from_pretrained(self.tmpdirname       ,		**SCREAMING_SNAKE_CASE_     )



							def       A__						(					self       ,		**SCREAMING_SNAKE_CASE_     )->				Union[str, Any]:





													'''simple docstring'''






													return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname       ,		**SCREAMING_SNAKE_CASE_     )



							def       A__						(					self     )->				str:





													'''simple docstring'''






													shutil.rmtree(self.tmpdirname     )



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





													'''simple docstring'''






													__UpperCamelCase       					=     self.get_tokenizer()
													__UpperCamelCase       					=     self.get_feature_extractor()

													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_       ,		feature_extractor=SCREAMING_SNAKE_CASE_     )

													processor.save_pretrained(self.tmpdirname     )
													__UpperCamelCase       					=     SpeechTaProcessor.from_pretrained(self.tmpdirname     )

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

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



							def       A__						(					self     )->				List[str]:





													'''simple docstring'''






													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=self.get_tokenizer()       ,		feature_extractor=self.get_feature_extractor()     )
													processor.save_pretrained(self.tmpdirname     )

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

													__UpperCamelCase       					=     SpeechTaProcessor.from_pretrained(
													    self.tmpdirname       ,		bos_token='''(BOS)'''       ,		eos_token='''(EOS)'''       ,		do_normalize=SCREAMING_SNAKE_CASE_       ,		padding_value=1.0     )

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

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



							def       A__						(					self     )->				Dict:





													'''simple docstring'''






													__UpperCamelCase       					=     self.get_feature_extractor()
													__UpperCamelCase       					=     self.get_tokenizer()

													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_       ,		feature_extractor=SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase       					=     floats_list((3, 1000)     )

													__UpperCamelCase       					=     feature_extractor(audio=SCREAMING_SNAKE_CASE_       ,		return_tensors='''np'''     )
													__UpperCamelCase       					=     processor(audio=SCREAMING_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       A__						(					self     )->				Dict:





													'''simple docstring'''






													__UpperCamelCase       					=     self.get_feature_extractor()
													__UpperCamelCase       					=     self.get_tokenizer()

													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_       ,		feature_extractor=SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase       					=     floats_list((3, 1000)     )

													__UpperCamelCase       					=     feature_extractor(audio_target=SCREAMING_SNAKE_CASE_       ,		return_tensors='''np'''     )
													__UpperCamelCase       					=     processor(audio_target=SCREAMING_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       A__						(					self     )->				int:





													'''simple docstring'''






													__UpperCamelCase       					=     self.get_feature_extractor()
													__UpperCamelCase       					=     self.get_tokenizer()

													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_       ,		feature_extractor=SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase       					=     '''This is a test string'''

													__UpperCamelCase       					=     processor(text=SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     tokenizer(SCREAMING_SNAKE_CASE_     )

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



							def       A__						(					self     )->				int:





													'''simple docstring'''






													__UpperCamelCase       					=     self.get_feature_extractor()
													__UpperCamelCase       					=     self.get_tokenizer()

													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_       ,		feature_extractor=SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase       					=     '''This is a test string'''

													__UpperCamelCase       					=     processor(text_target=SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     tokenizer(SCREAMING_SNAKE_CASE_     )

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



							def       A__						(					self     )->				Dict:





													'''simple docstring'''






													__UpperCamelCase       					=     self.get_feature_extractor()
													__UpperCamelCase       					=     self.get_tokenizer()

													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_       ,		feature_extractor=SCREAMING_SNAKE_CASE_     )

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

													__UpperCamelCase       					=     processor.batch_decode(SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     tokenizer.batch_decode(SCREAMING_SNAKE_CASE_     )

													self.assertListEqual(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_     )



							def       A__						(					self     )->				List[str]:





													'''simple docstring'''






													__UpperCamelCase       					=     self.get_feature_extractor()
													__UpperCamelCase       					=     self.get_tokenizer()

													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_       ,		feature_extractor=SCREAMING_SNAKE_CASE_     )

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




