from __future__ import annotations

import inspect
import unittest
from math import floor

import numpy as np

from transformers import CvtConfig
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 TFCvtForImageClassification, TFCvtModel
		from transformers.models.cvt.modeling_tf_cvt import TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor




class   _UpperCamelCase (		_UpperCAmelCase					):


			"""simple docstring"""






			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Dict:

							'''simple docstring'''


							__lowercase					     =				self.config_class(**self.inputs_dict		)
							self.parent.assertTrue(hasattr(lowerCAmelCase__ ,  '''embed_dim'''		)		)
							self.parent.assertTrue(hasattr(lowerCAmelCase__ ,  '''num_heads'''		)		)




class   _UpperCamelCase :


			"""simple docstring"""






			def __init__(  self ,  lowerCAmelCase__ ,  lowerCAmelCase__=13 ,  lowerCAmelCase__=64 ,  lowerCAmelCase__=3 ,  lowerCAmelCase__=[16, 48, 96] ,  lowerCAmelCase__=[1, 3, 6] ,  lowerCAmelCase__=[1, 2, 10] ,  lowerCAmelCase__=[7, 3, 3] ,  lowerCAmelCase__=[4, 2, 2] ,  lowerCAmelCase__=[2, 1, 1] ,  lowerCAmelCase__=[2, 2, 2] ,  lowerCAmelCase__=[False, False, True] ,  lowerCAmelCase__=[0.0, 0.0, 0.0] ,  lowerCAmelCase__=0.02 ,  lowerCAmelCase__=1E-12 ,  lowerCAmelCase__=True ,  lowerCAmelCase__=True ,  lowerCAmelCase__=2 ,  )	->   str:

							'''simple docstring'''


							__lowercase					     =				parent
							__lowercase					     =				batch_size
							__lowercase					     =				image_size
							__lowercase					     =				patch_sizes
							__lowercase					     =				patch_stride
							__lowercase					     =				patch_padding
							__lowercase					     =				is_training
							__lowercase					     =				use_labels
							__lowercase					     =				num_labels
							__lowercase					     =				num_channels
							__lowercase					     =				embed_dim
							__lowercase					     =				num_heads
							__lowercase					     =				stride_kv
							__lowercase					     =				depth
							__lowercase					     =				cls_token
							__lowercase					     =				attention_drop_rate
							__lowercase					     =				initializer_range
							__lowercase					     =				layer_norm_eps





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Union[str, Any]:

							'''simple docstring'''


							__lowercase					     =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

							__lowercase					     =				None
							if self.use_labels:
											# create a random int32 tensor of given shape
											__lowercase					     =				ids_tensor([self.batch_size] ,  self.num_labels		)

							__lowercase					     =				self.get_config()
							return config, pixel_values, labels





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

							'''simple docstring'''


							return CvtConfig(
							    image_size=self.image_size ,  num_labels=self.num_labels ,  num_channels=self.num_channels ,  embed_dim=self.embed_dim ,  num_heads=self.num_heads ,  patch_sizes=self.patch_sizes ,  patch_padding=self.patch_padding ,  patch_stride=self.patch_stride ,  stride_kv=self.stride_kv ,  depth=self.depth ,  cls_token=self.cls_token ,  attention_drop_rate=self.attention_drop_rate ,  initializer_range=self.initializer_range ,  )





			def 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)	->   int:

							'''simple docstring'''


							__lowercase					     =				TFCvtModel(config=lowerCAmelCase__		)
							__lowercase					     =				model(lowerCAmelCase__ ,  training=lowerCAmelCase__		)
							__lowercase					     =				(self.image_size, self.image_size)
							__lowercase     ,	__lowercase					     =				image_size[0], image_size[1]
							for i in range(len(self.depth		)		):
											__lowercase					     =				floor(((height + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1		)
											__lowercase					     =				floor(((width + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1		)
							self.parent.assertEqual(result.last_hidden_state.shape ,  (self.batch_size, self.embed_dim[-1], height, width)		)





			def 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)	->   int:

							'''simple docstring'''


							__lowercase					     =				self.num_labels
							__lowercase					     =				TFCvtForImageClassification(lowerCAmelCase__		)
							__lowercase					     =				model(lowerCAmelCase__ ,  labels=lowerCAmelCase__ ,  training=lowerCAmelCase__		)
							self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_labels)		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Union[str, Any]:

							'''simple docstring'''


							__lowercase					     =				self.prepare_config_and_inputs()
							__lowercase     ,	__lowercase     ,	__lowercase					     =				config_and_inputs
							__lowercase					     =				{'''pixel_values''': pixel_values}
							return config, inputs_dict




@require_tf
class   _UpperCamelCase (		_UpperCAmelCase		,_UpperCAmelCase		,unittest.TestCase					):


			"""simple docstring"""






			__a    :					Dict     					=		(TFCvtModel, TFCvtForImageClassification) if is_tf_available() else ()
			__a    :					List[str]     					=		(
			    {'''feature-extraction''': TFCvtModel, '''image-classification''': TFCvtForImageClassification}
			    if is_tf_available()
			    else {}
			)
			__a    :					Tuple     					=		False
			__a    :					Optional[Any]     					=		False
			__a    :					Tuple     					=		False
			__a    :					str     					=		False
			__a    :					int     					=		False





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Any:

							'''simple docstring'''


							__lowercase					     =				TFCvtModelTester(self		)
							__lowercase					     =				TFCvtConfigTester(self ,  config_class=lowerCAmelCase__ ,  has_text_modality=lowerCAmelCase__ ,  hidden_size=37		)





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

							'''simple docstring'''


							self.config_tester.create_and_test_config_common_properties()
							self.config_tester.create_and_test_config_to_json_string()
							self.config_tester.create_and_test_config_to_json_file()
							self.config_tester.create_and_test_config_from_and_save_pretrained()
							self.config_tester.create_and_test_config_with_num_labels()
							self.config_tester.check_config_can_be_init_without_params()
							self.config_tester.check_config_arguments_init()





			@unittest.skip(reason='''Cvt does not output attentions'''		)
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Optional[Any]:

							'''simple docstring'''


							pass





			@unittest.skip(reason='''Cvt does not use inputs_embeds'''		)
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   List[Any]:

							'''simple docstring'''


							pass





			@unittest.skip(reason='''Cvt does not support input and output embeddings'''		)
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   str:

							'''simple docstring'''


							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.''' ,  )
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Union[str, Any]:

							'''simple docstring'''


							super().test_dataset_conversion()





			@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 			_SCREAMING_SNAKE_CASE     (  self		)	->   Optional[Any]:

							'''simple docstring'''


							super().test_keras_fit()





			@unittest.skip(reason='''Get `Failed to determine best cudnn convolution algo.` error after using TF 2.12+cuda 11.8'''		)
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Optional[Any]:

							'''simple docstring'''


							__lowercase					     =				tf.keras.mixed_precision.Policy('''mixed_float16'''		)
							tf.keras.mixed_precision.set_global_policy(lowerCAmelCase__		)
							super().test_keras_fit()
							tf.keras.mixed_precision.set_global_policy('''float32'''		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							__lowercase     ,	__lowercase					     =				self.model_tester.prepare_config_and_inputs_for_common()

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

											__lowercase					     =				['''pixel_values''']
											self.assertListEqual(arg_names[:1] ,  lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Any:

							'''simple docstring'''


							def check_hidden_states_output(lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		):
											__lowercase					     =				model_class(lowerCAmelCase__		)

											__lowercase					     =				model(**self._prepare_for_class(lowerCAmelCase__ ,  lowerCAmelCase__		)		)
											__lowercase					     =				outputs.hidden_states

											__lowercase					     =				len(self.model_tester.depth		)
											self.assertEqual(len(lowerCAmelCase__		) ,  lowerCAmelCase__		)

											# verify the first hidden states (first block)
											self.assertListEqual(
											    list(hidden_states[0].shape[-3:]		) ,  [
											        self.model_tester.embed_dim[0],
											        self.model_tester.image_size // 4,
											        self.model_tester.image_size // 4,
											    ] ,  )

							__lowercase     ,	__lowercase					     =				self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											__lowercase					     =				True
											check_hidden_states_output(lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)

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

											check_hidden_states_output(lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   str:

							'''simple docstring'''


							__lowercase					     =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Optional[Any]:

							'''simple docstring'''


							__lowercase					     =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__		)





			@slow
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   List[str]:

							'''simple docstring'''


							for model_name in TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase					     =				TFCvtModel.from_pretrained(lowerCAmelCase__		)
											self.assertIsNotNone(lowerCAmelCase__		)





def 							UpperCAmelCase		(       ):







				"""simple docstring"""



				__lowercase					     =				Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
				return image




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


			"""simple docstring"""






			@cached_property
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Tuple:

							'''simple docstring'''


							return AutoImageProcessor.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)





			@slow
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							__lowercase					     =				TFCvtForImageClassification.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)

							__lowercase					     =				self.default_image_processor
							__lowercase					     =				prepare_img()
							__lowercase					     =				image_processor(images=lowerCAmelCase__ ,  return_tensors='''tf'''		)

							# forward pass
							__lowercase					     =				model(**lowerCAmelCase__		)

							# verify the logits
							__lowercase					     =				tf.TensorShape((1, 10_00)		)
							self.assertEqual(outputs.logits.shape ,  lowerCAmelCase__		)

							__lowercase					     =				tf.constant([0.9285, 0.9015, -0.3150]		)
							self.assertTrue(np.allclose(outputs.logits[0, :3].numpy() ,  lowerCAmelCase__ ,  atol=1E-4		)		)
from argparse import ArgumentParser

from .env import EnvironmentCommand





def 							UpperCAmelCase		(       ):







				"""simple docstring"""



				__lowercase					     =				ArgumentParser('''Diffusers CLI tool'''				,     usage='''diffusers-cli <command> [<args>]'''				)
				__lowercase					     =				parser.add_subparsers(help='''diffusers-cli command helpers'''				)

				# Register commands
				EnvironmentCommand.register_subcommand(lowercase				)

				# Let's go
				__lowercase					     =				parser.parse_args()

				if not hasattr(lowercase				,     '''func'''				):
								parser.print_help()
								exit(1				)

				# Run
				__lowercase					     =				args.func(lowercase				)
				service.run()


if __name__ == "__main__":
		main()