



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


A__       =			get_tests_dir("""fixtures/test_sentencepiece_bpe_char.model""")





@require_torch
class    __lowerCAmelCase					(	unittest.TestCase			):




				def 				snake_case  (				self						):



									"""simple docstring"""





									_lowerCAmelCase         =       tempfile.mkdtemp()

									_lowerCAmelCase         =       SpeechTaTokenizer(_snake_case						)
									tokenizer.save_pretrained(self.tmpdirname						)

									_lowerCAmelCase         =       {
									    """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,
									}

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




				def 				snake_case  (				self		,							**_snake_case						):



									"""simple docstring"""





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




				def 				snake_case  (				self		,							**_snake_case						):



									"""simple docstring"""





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




				def 				snake_case  (				self						):



									"""simple docstring"""





									shutil.rmtree(self.tmpdirname						)




				def 				snake_case  (				self						):



									"""simple docstring"""





									_lowerCAmelCase         =       self.get_tokenizer()
									_lowerCAmelCase         =       self.get_feature_extractor()

									_lowerCAmelCase         =       SpeechTaProcessor(tokenizer=_snake_case		,							feature_extractor=_snake_case						)

									processor.save_pretrained(self.tmpdirname						)
									_lowerCAmelCase         =       SpeechTaProcessor.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 				snake_case  (				self						):



									"""simple docstring"""





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

									_lowerCAmelCase         =       self.get_tokenizer(bos_token="""(BOS)"""		,							eos_token="""(EOS)"""						)
									_lowerCAmelCase         =       self.get_feature_extractor(do_normalize=_snake_case		,							padding_value=1.0						)

									_lowerCAmelCase         =       SpeechTaProcessor.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 				snake_case  (				self						):



									"""simple docstring"""





									_lowerCAmelCase         =       self.get_feature_extractor()
									_lowerCAmelCase         =       self.get_tokenizer()

									_lowerCAmelCase         =       SpeechTaProcessor(tokenizer=_snake_case		,							feature_extractor=_snake_case						)

									_lowerCAmelCase         =       floats_list((3, 1000)						)

									_lowerCAmelCase         =       feature_extractor(audio=_snake_case		,							return_tensors="""np"""						)
									_lowerCAmelCase         =       processor(audio=_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 				snake_case  (				self						):



									"""simple docstring"""





									_lowerCAmelCase         =       self.get_feature_extractor()
									_lowerCAmelCase         =       self.get_tokenizer()

									_lowerCAmelCase         =       SpeechTaProcessor(tokenizer=_snake_case		,							feature_extractor=_snake_case						)

									_lowerCAmelCase         =       floats_list((3, 1000)						)

									_lowerCAmelCase         =       feature_extractor(audio_target=_snake_case		,							return_tensors="""np"""						)
									_lowerCAmelCase         =       processor(audio_target=_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 				snake_case  (				self						):



									"""simple docstring"""





									_lowerCAmelCase         =       self.get_feature_extractor()
									_lowerCAmelCase         =       self.get_tokenizer()

									_lowerCAmelCase         =       SpeechTaProcessor(tokenizer=_snake_case		,							feature_extractor=_snake_case						)

									_lowerCAmelCase         =       """This is a test string"""

									_lowerCAmelCase         =       processor(text=_snake_case						)
									_lowerCAmelCase         =       tokenizer(_snake_case						)

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




				def 				snake_case  (				self						):



									"""simple docstring"""





									_lowerCAmelCase         =       self.get_feature_extractor()
									_lowerCAmelCase         =       self.get_tokenizer()

									_lowerCAmelCase         =       SpeechTaProcessor(tokenizer=_snake_case		,							feature_extractor=_snake_case						)

									_lowerCAmelCase         =       """This is a test string"""

									_lowerCAmelCase         =       processor(text_target=_snake_case						)
									_lowerCAmelCase         =       tokenizer(_snake_case						)

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




				def 				snake_case  (				self						):



									"""simple docstring"""





									_lowerCAmelCase         =       self.get_feature_extractor()
									_lowerCAmelCase         =       self.get_tokenizer()

									_lowerCAmelCase         =       SpeechTaProcessor(tokenizer=_snake_case		,							feature_extractor=_snake_case						)

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

									_lowerCAmelCase         =       processor.batch_decode(_snake_case						)
									_lowerCAmelCase         =       tokenizer.batch_decode(_snake_case						)

									self.assertListEqual(_snake_case		,							_snake_case						)




				def 				snake_case  (				self						):



									"""simple docstring"""





									_lowerCAmelCase         =       self.get_feature_extractor()
									_lowerCAmelCase         =       self.get_tokenizer()

									_lowerCAmelCase         =       SpeechTaProcessor(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"""		,							)






'''simple docstring'''

from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import ConvNextConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
						import tensorflow as tf

						from transformers import TFConvNextForImageClassification, TFConvNextModel


if is_vision_available():
						from PIL import Image

						from transformers import ConvNextImageProcessor







class lowerCamelCase   :

				def __init__(       self,						lowercase_,						lowercase_=13,						lowercase_=32,						lowercase_=3,						lowercase_=4,						lowercase_=[10, 20, 30, 40],						lowercase_=[2, 2, 3, 2],						lowercase_=True,						lowercase_=True,						lowercase_=37,						lowercase_="gelu",						lowercase_=10,						lowercase_=0.02,						lowercase_=3,						lowercase_=None,						)    ->							Dict:
					snake_case							=					parent
					snake_case							=					batch_size
					snake_case							=					image_size
					snake_case							=					num_channels
					snake_case							=					num_stages
					snake_case							=					hidden_sizes
					snake_case							=					depths
					snake_case							=					is_training
					snake_case							=					use_labels
					snake_case							=					intermediate_size
					snake_case							=					hidden_act
					snake_case							=					type_sequence_label_size
					snake_case							=					initializer_range
					snake_case							=					scope

				def 					_lowerCamelCase    (       self )    ->							List[Any]:
					snake_case							=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

					snake_case							=					None
					if self.use_labels:
						snake_case							=					ids_tensor([self.batch_size],						self.type_sequence_label_size )

					snake_case							=					self.get_config()

					return config, pixel_values, labels

				def 					_lowerCamelCase    (       self )    ->							Any:
					return ConvNextConfig(
					    num_channels=self.num_channels,						hidden_sizes=self.hidden_sizes,						depths=self.depths,						num_stages=self.num_stages,						hidden_act=self.hidden_act,						is_decoder=lowercase_,						initializer_range=self.initializer_range,						)

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_ )    ->							List[Any]:
					snake_case							=					TFConvNextModel(config=lowercase_ )
					snake_case							=					model(lowercase_,						training=lowercase_ )
					# expected last hidden states: B, C, H // 32, W // 32
					self.parent.assertEqual(
					    result.last_hidden_state.shape,						(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32),						)

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_ )    ->							Union[str, Any]:
					snake_case							=					self.type_sequence_label_size
					snake_case							=					TFConvNextForImageClassification(lowercase_ )
					snake_case							=					model(lowercase_,						labels=lowercase_,						training=lowercase_ )
					self.parent.assertEqual(result.logits.shape,						(self.batch_size, self.type_sequence_label_size) )






				def 					_lowerCamelCase    (       self )    ->							Optional[int]:
					snake_case							=					self.prepare_config_and_inputs()
					snake_case			,			snake_case			,			snake_case							=					config_and_inputs
					snake_case							=					{'pixel_values': pixel_values}
					return config, inputs_dict







@require_tf
class lowerCamelCase   (    __lowerCAmelCase				,				__lowerCAmelCase				,				unittest.TestCase				):
				snake_case_							     = (TFConvNextModel, TFConvNextForImageClassification) if is_tf_available() else ()
				snake_case_							     = (
				    {'''feature-extraction''': TFConvNextModel, '''image-classification''': TFConvNextForImageClassification}
				    if is_tf_available()
				    else {}
				)

				snake_case_							     = False
				snake_case_							     = False
				snake_case_							     = False
				snake_case_							     = False
				snake_case_							     = False

				def 					_lowerCamelCase    (       self )    ->							str:
					snake_case							=					TFConvNextModelTester(self )
					snake_case							=					ConfigTester(
					    self,						config_class=lowercase_,						has_text_modality=lowercase_,						hidden_size=37,						)

				@unittest.skip(reason='ConvNext does not use inputs_embeds' )
				def 					_lowerCamelCase    (       self )    ->							Tuple:
					pass

				@unittest.skipIf(
				    not is_tf_available() or len(tf.config.list_physical_devices('GPU' ) ) == 0,						reason='TF does not support backprop for grouped convolutions on CPU.',						)
				@slow
				def 					_lowerCamelCase    (       self )    ->							Optional[Any]:
					super().test_keras_fit()

				@unittest.skip(reason='ConvNext does not support input and output embeddings' )
				def 					_lowerCamelCase    (       self )    ->							Dict:
					pass

				def 					_lowerCamelCase    (       self )    ->							List[Any]:
					snake_case			,			snake_case							=					self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						snake_case							=					model_class(lowercase_ )
						snake_case							=					inspect.signature(model.call )
						# signature.parameters is an OrderedDict => so arg_names order is deterministic
						snake_case							=					[*signature.parameters.keys()]

						snake_case							=					['pixel_values']
						self.assertListEqual(arg_names[:1],						lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							str:
					snake_case							=					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*lowercase_ )

				@unittest.skipIf(
				    not is_tf_available() or len(tf.config.list_physical_devices('GPU' ) ) == 0,						reason='TF does not support backprop for grouped convolutions on CPU.',						)
				def 					_lowerCamelCase    (       self )    ->							Optional[int]:
					super().test_dataset_conversion()

				def 					_lowerCamelCase    (       self )    ->							Union[str, Any]:
					def check_hidden_states_output(lowercase_,						lowercase_,						lowercase_ ):
						snake_case							=					model_class(lowercase_ )

						snake_case							=					model(**self._prepare_for_class(lowercase_,						lowercase_ ) )
						snake_case							=					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

						snake_case							=					self.model_tester.num_stages
						self.assertEqual(len(lowercase_ ),						expected_num_stages + 1 )

						# ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
						self.assertListEqual(
						    list(hidden_states[0].shape[-2:] ),						[self.model_tester.image_size // 4, self.model_tester.image_size // 4],						)

					snake_case			,			snake_case							=					self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						snake_case							=					True
						check_hidden_states_output(lowercase_,						lowercase_,						lowercase_ )

						# check that output_hidden_states also work using config
						del inputs_dict["output_hidden_states"]
						snake_case							=					True

						check_hidden_states_output(lowercase_,						lowercase_,						lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							Dict:
					snake_case			,			snake_case							=					self.model_tester.prepare_config_and_inputs_for_common()

					def check_equivalence(lowercase_,						lowercase_,						lowercase_,						lowercase_={} ):
						snake_case							=					model(lowercase_,						return_dict=lowercase_,						**lowercase_ )
						snake_case							=					model(lowercase_,						return_dict=lowercase_,						**lowercase_ ).to_tuple()

						def recursive_check(lowercase_,						lowercase_ ):
							if isinstance(lowercase_,						(List, Tuple) ):
								for tuple_iterable_value, dict_iterable_value in zip(lowercase_,						lowercase_ ):
									recursive_check(lowercase_,						lowercase_ )
							elif tuple_object is None:
								return
							else:
								self.assertTrue(
								    all(tf.equal(lowercase_,						lowercase_ ) ),						msg=(
								        'Tuple and dict output are not equal. Difference:'
								        F''' {tf.math.reduce_max(tf.abs(tuple_object - dict_object ) )}'''
								    ),						)

							recursive_check(lowercase_,						lowercase_ )

					for model_class in self.all_model_classes:
						snake_case							=					model_class(lowercase_ )

						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_ )
						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_ )
						check_equivalence(lowercase_,						lowercase_,						lowercase_ )

						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_,						return_labels=lowercase_ )
						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_,						return_labels=lowercase_ )
						check_equivalence(lowercase_,						lowercase_,						lowercase_ )

						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_ )
						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_ )
						check_equivalence(lowercase_,						lowercase_,						lowercase_,						{'output_hidden_states': True} )

						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_,						return_labels=lowercase_ )
						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_,						return_labels=lowercase_ )
						check_equivalence(lowercase_,						lowercase_,						lowercase_,						{'output_hidden_states': True} )

				def 					_lowerCamelCase    (       self )    ->							List[str]:
					snake_case							=					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*lowercase_ )






				@slow
				def 					_lowerCamelCase    (       self )    ->							str:
					snake_case							=					TFConvNextModel.from_pretrained('facebook/convnext-tiny-224' )
					self.assertIsNotNone(lowercase_ )

def      __magic_name__							(			)      ->		Optional[int]:
	snake_case							=					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
	return image







@require_tf
@require_vision
class lowerCamelCase   (    unittest.TestCase				):

				@cached_property
				def 					_lowerCamelCase    (       self )    ->							List[str]:
					return ConvNextImageProcessor.from_pretrained('facebook/convnext-tiny-224' ) if is_vision_available() else None






				@slow
				def 					_lowerCamelCase    (       self )    ->							Dict:
					snake_case							=					TFConvNextForImageClassification.from_pretrained('facebook/convnext-tiny-224' )

					snake_case							=					self.default_image_processor
					snake_case							=					prepare_img()
					snake_case							=					image_processor(images=lowercase_,						return_tensors='tf' )

					# forward pass
					snake_case							=					model(**lowercase_ )

					# verify the logits
					snake_case							=					tf.TensorShape((1, 1000) )
					self.assertEqual(outputs.logits.shape,						lowercase_ )

					snake_case							=					tf.constant([-0.0_260, -0.4_739, 0.1_911] )

					tf.debugging.assert_near(outputs.logits[0, :3],						lowercase_,						atol=1E-4 )





