




import unittest
from pathlib import Path
from tempfile import TemporaryDirectory

from transformers import AutoConfig, TFAutoModel, is_tensorflow_text_available, is_tf_available
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.testing_utils import require_tensorflow_text, require_tf, slow


if is_tf_available():
						import tensorflow as tf

if is_tensorflow_text_available():
						from transformers.models.bert import TFBertTokenizer


UpperCamelCase__ :   Union[str, Any]						=							['''bert-base-uncased''', '''bert-base-cased''']
UpperCamelCase__ :   Optional[int]						=							'''hf-internal-testing/tiny-bert-tf-only'''

if is_tf_available():







						class 				lowerCAmelCase_       (					tf.keras.Model							):






										def __init__(			self      ,snake_case__ ):
													super().__init__()
													SCREAMING_SNAKE_CASE_   : Any					  =      tokenizer
													SCREAMING_SNAKE_CASE_   : Any					  =      AutoConfig.from_pretrained(snake_case__ )
													SCREAMING_SNAKE_CASE_   : str					  =      TFAutoModel.from_config(snake_case__ )






										def 		snake_case	(			self      ,snake_case__ ):
													SCREAMING_SNAKE_CASE_   : Optional[int]					  =      self.tokenizer(snake_case__ )
													SCREAMING_SNAKE_CASE_   : str					  =      self.bert(**snake_case__ )
													return out["pooler_output"]







@require_tf
@require_tensorflow_text
class 				lowerCAmelCase_       (					unittest.TestCase							):






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

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      [
							    BertTokenizer.from_pretrained(snake_case__ ) for checkpoint in (TOKENIZER_CHECKPOINTS * 2)
							]  # repeat for when fast_bert_tokenizer=false
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      [TFBertTokenizer.from_pretrained(snake_case__ ) for checkpoint in TOKENIZER_CHECKPOINTS] + [
							    TFBertTokenizer.from_pretrained(snake_case__      ,use_fast_bert_tokenizer=snake_case__ )
							    for checkpoint in TOKENIZER_CHECKPOINTS
							]
							assert len(self.tokenizers ) == len(self.tf_tokenizers )

							SCREAMING_SNAKE_CASE_   : Dict					  =      [
							    'This is a straightforward English test sentence.',
							    'This one has some weird characters\rto\nsee\r\nif  those\u00E9break things.',
							    'Now we\'re going to add some Chinese: 一 二 三 一二三',
							    'And some much more rare Chinese: 齉 堃 齉堃',
							    'Je vais aussi écrire en français pour tester les accents',
							    'Classical Irish also has some unusual characters, so in they go: Gaelaċ, ꝼ',
							]
							SCREAMING_SNAKE_CASE_   : Dict					  =      list(zip(self.test_sentences      ,self.test_sentences[::-1] ) )






				def 		snake_case	(			self ):
							for tokenizer, tf_tokenizer in zip(self.tokenizers      ,self.tf_tokenizers ):
										for test_inputs in (self.test_sentences, self.paired_sentences):
													SCREAMING_SNAKE_CASE_   : Optional[int]					  =      tokenizer(snake_case__      ,return_tensors='tf'      ,padding='longest' )
													SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      tf_tokenizer(snake_case__ )

													for key in python_outputs.keys():
																self.assertTrue(tf.reduce_all(python_outputs[key].shape == tf_outputs[key].shape ) )
																self.assertTrue(tf.reduce_all(tf.cast(python_outputs[key]      ,tf.intaa ) == tf_outputs[key] ) )






				@slow
				def 		snake_case	(			self ):
							for tf_tokenizer in self.tf_tokenizers:
										SCREAMING_SNAKE_CASE_   : int					  =      tf_tokenizer(self.paired_sentences )
										SCREAMING_SNAKE_CASE_   : List[Any]					  =      tf_tokenizer(
										    text=[sentence[0] for sentence in self.paired_sentences]      ,text_pair=[sentence[1] for sentence in self.paired_sentences]      ,)
										for key in merged_outputs.keys():
													self.assertTrue(tf.reduce_all(tf.cast(merged_outputs[key]      ,tf.intaa ) == separated_outputs[key] ) )






				@slow
				def 		snake_case	(			self ):
							for tf_tokenizer in self.tf_tokenizers:
										SCREAMING_SNAKE_CASE_   : str					  =      tf.function(snake_case__ )
										for test_inputs in (self.test_sentences, self.paired_sentences):
													SCREAMING_SNAKE_CASE_   : List[Any]					  =      tf.constant(snake_case__ )
													SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      compiled_tokenizer(snake_case__ )
													SCREAMING_SNAKE_CASE_   : Dict					  =      tf_tokenizer(snake_case__ )

													for key in eager_outputs.keys():
																self.assertTrue(tf.reduce_all(eager_outputs[key] == compiled_outputs[key] ) )






				@slow
				def 		snake_case	(			self ):
							for tf_tokenizer in self.tf_tokenizers:
										SCREAMING_SNAKE_CASE_   : int					  =      ModelToSave(tokenizer=snake_case__ )
										SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      tf.convert_to_tensor(self.test_sentences )
										SCREAMING_SNAKE_CASE_   : List[Any]					  =      model(snake_case__ )  # Build model with some sample inputs
										with TemporaryDirectory() as tempdir:
													SCREAMING_SNAKE_CASE_   : Any					  =      Path(snake_case__ ) / 'saved.model'
													model.save(snake_case__ )
													SCREAMING_SNAKE_CASE_   : Any					  =      tf.keras.models.load_model(snake_case__ )
										SCREAMING_SNAKE_CASE_   : Tuple					  =      loaded_model(snake_case__ )
										# We may see small differences because the loaded model is compiled, so we need an epsilon for the test
										self.assertLessEqual(tf.reduce_max(tf.abs(out - loaded_output ) )      ,1E-5 )









from typing import TYPE_CHECKING

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


UpperCamelCase__ :   Optional[Any]						=							{
    '''configuration_whisper''': ['''WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''WhisperConfig''', '''WhisperOnnxConfig'''],
    '''feature_extraction_whisper''': ['''WhisperFeatureExtractor'''],
    '''processing_whisper''': ['''WhisperProcessor'''],
    '''tokenization_whisper''': ['''WhisperTokenizer'''],
}

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						UpperCamelCase__ :   str						=							['''WhisperTokenizerFast''']

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						UpperCamelCase__ :   List[Any]						=							[
						    '''WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''WhisperForConditionalGeneration''',
						    '''WhisperModel''',
						    '''WhisperPreTrainedModel''',
						    '''WhisperForAudioClassification''',
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						UpperCamelCase__ :   Tuple						=							[
						    '''TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''TFWhisperForConditionalGeneration''',
						    '''TFWhisperModel''',
						    '''TFWhisperPreTrainedModel''',
						]

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						UpperCamelCase__ :   List[str]						=							[
						    '''FlaxWhisperForConditionalGeneration''',
						    '''FlaxWhisperModel''',
						    '''FlaxWhisperPreTrainedModel''',
						    '''FlaxWhisperForAudioClassification''',
						]


if TYPE_CHECKING:
						from .configuration_whisper import WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP, WhisperConfig, WhisperOnnxConfig
						from .feature_extraction_whisper import WhisperFeatureExtractor
						from .processing_whisper import WhisperProcessor
						from .tokenization_whisper import WhisperTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_whisper_fast import WhisperTokenizerFast

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_whisper import (
												    WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    WhisperForAudioClassification,
												    WhisperForConditionalGeneration,
												    WhisperModel,
												    WhisperPreTrainedModel,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_whisper import (
												    TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFWhisperForConditionalGeneration,
												    TFWhisperModel,
												    TFWhisperPreTrainedModel,
												)

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_whisper import (
												    FlaxWhisperForAudioClassification,
												    FlaxWhisperForConditionalGeneration,
												    FlaxWhisperModel,
												    FlaxWhisperPreTrainedModel,
												)

else:
						import sys

						UpperCamelCase__ :   Optional[Any]						=							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



