


from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
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 TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor
class 	lowerCamelCase_       :



					'''simple docstring'''







					def __init__(				self ,       snake_case_ ,       snake_case_=3 ,       snake_case_=3_2 ,       snake_case_=3 ,       snake_case_=1_0 ,       snake_case_=[1_0, 2_0, 3_0, 4_0] ,       snake_case_=[1, 1, 2, 1] ,       snake_case_=True ,       snake_case_=True ,       snake_case_="relu" ,       snake_case_=3 ,       snake_case_=None ,       )   ->			Any:







								'''simple docstring'''

								__lowercase 					=   parent
								__lowercase 					=   batch_size
								__lowercase 					=   image_size
								__lowercase 					=   num_channels
								__lowercase 					=   embeddings_size
								__lowercase 					=   hidden_sizes
								__lowercase 					=   depths
								__lowercase 					=   is_training
								__lowercase 					=   use_labels
								__lowercase 					=   hidden_act
								__lowercase 					=   num_labels
								__lowercase 					=   scope
								__lowercase 					=   len(snake_case_						)






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







								'''simple docstring'''

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

								__lowercase 					=   None
								if self.use_labels:
											__lowercase 					=   ids_tensor([self.batch_size] ,       self.num_labels						)

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






					def A      (				self						)   ->			Dict:







								'''simple docstring'''

								return RegNetConfig(
								    num_channels=self.num_channels ,       embeddings_size=self.embeddings_size ,       hidden_sizes=self.hidden_sizes ,       depths=self.depths ,       hidden_act=self.hidden_act ,       num_labels=self.num_labels ,       )






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_						)   ->			int:







								'''simple docstring'''

								__lowercase 					=   TFRegNetModel(config=snake_case_						)
								__lowercase 					=   model(snake_case_ ,       training=snake_case_						)
								# 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 // 3_2, self.image_size // 3_2) ,       )






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_						)   ->			List[Any]:







								'''simple docstring'''

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






					def A      (				self						)   ->			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 	lowerCamelCase_       (				lowerCAmelCase__     ,     lowerCAmelCase__     ,     unittest.TestCase				):



					'''simple docstring'''







					__UpperCAmelCase            =				(TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
					__UpperCAmelCase            =				(
					    {"feature-extraction": TFRegNetModel, "image-classification": TFRegNetForImageClassification}
					    if is_tf_available()
					    else {}
					)

					__UpperCAmelCase            =				False
					__UpperCAmelCase            =				False
					__UpperCAmelCase            =				False
					__UpperCAmelCase            =				False
					__UpperCAmelCase            =				False






					def A      (				self						)   ->			Tuple:







								'''simple docstring'''

								__lowercase 					=   TFRegNetModelTester(self						)
								__lowercase 					=   ConfigTester(self ,       config_class=snake_case_ ,       has_text_modality=snake_case_						)






					def A      (				self						)   ->			int:







								'''simple docstring'''

								return






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







								'''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.''' ,       )
					@slow
					def A      (				self						)   ->			List[str]:







								'''simple docstring'''

								super().test_keras_fit()






					@unittest.skip(reason='''RegNet does not support input and output embeddings'''						)
					def A      (				self						)   ->			List[Any]:







								'''simple docstring'''

								pass






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







								'''simple docstring'''

								__lowercase					, __lowercase 					=   self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											__lowercase 					=   model_class(snake_case_						)
											__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] ,       snake_case_						)






					def A      (				self						)   ->			Dict:







								'''simple docstring'''

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






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







								'''simple docstring'''

								def check_hidden_states_output(snake_case_ ,       snake_case_ ,       snake_case_						):
											__lowercase 					=   model_class(snake_case_						)
											__lowercase 					=   model(**self._prepare_for_class(snake_case_ ,       snake_case_						) ,       training=snake_case_						)

											__lowercase 					=   outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

											__lowercase 					=   self.model_tester.num_stages
											self.assertEqual(len(snake_case_						) ,       expected_num_stages + 1						)

											# RegNet'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 // 2, self.model_tester.image_size // 2] ,       )

								__lowercase					, __lowercase 					=   self.model_tester.prepare_config_and_inputs_for_common()
								__lowercase 					=   ['''basic''', '''bottleneck''']
								for model_class in self.all_model_classes:
											for layer_type in layers_type:
														__lowercase 					=   layer_type
														__lowercase 					=   True
														check_hidden_states_output(snake_case_ ,       snake_case_ ,       snake_case_						)

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

														check_hidden_states_output(snake_case_ ,       snake_case_ ,       snake_case_						)






					def A      (				self						)   ->			str:







								'''simple docstring'''

								__lowercase					, __lowercase 					=   self.model_tester.prepare_config_and_inputs_for_common()

								def check_equivalence(snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_={}						):
											__lowercase 					=   model(snake_case_ ,       return_dict=snake_case_ ,       **snake_case_						)
											__lowercase 					=   model(snake_case_ ,       return_dict=snake_case_ ,       **snake_case_						).to_tuple()

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

														recursive_check(snake_case_ ,       snake_case_						)

								for model_class in self.all_model_classes:
											__lowercase 					=   model_class(snake_case_						)

											__lowercase 					=   self._prepare_for_class(snake_case_ ,       snake_case_						)
											__lowercase 					=   self._prepare_for_class(snake_case_ ,       snake_case_						)
											check_equivalence(snake_case_ ,       snake_case_ ,       snake_case_						)

											__lowercase 					=   self._prepare_for_class(snake_case_ ,       snake_case_ ,       return_labels=snake_case_						)
											__lowercase 					=   self._prepare_for_class(snake_case_ ,       snake_case_ ,       return_labels=snake_case_						)
											check_equivalence(snake_case_ ,       snake_case_ ,       snake_case_						)

											__lowercase 					=   self._prepare_for_class(snake_case_ ,       snake_case_						)
											__lowercase 					=   self._prepare_for_class(snake_case_ ,       snake_case_						)
											check_equivalence(snake_case_ ,       snake_case_ ,       snake_case_ ,       {'''output_hidden_states''': True}						)

											__lowercase 					=   self._prepare_for_class(snake_case_ ,       snake_case_ ,       return_labels=snake_case_						)
											__lowercase 					=   self._prepare_for_class(snake_case_ ,       snake_case_ ,       return_labels=snake_case_						)
											check_equivalence(snake_case_ ,       snake_case_ ,       snake_case_ ,       {'''output_hidden_states''': True}						)






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







								'''simple docstring'''

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






					@slow
					def A      (				self						)   ->			Dict:







								'''simple docstring'''

								for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase 					=   TFRegNetModel.from_pretrained(snake_case_						)
											self.assertIsNotNone(snake_case_						)




def 		lowercase_  (     ):


			'''simple docstring'''







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





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



					'''simple docstring'''







					@cached_property
					def A      (				self						)   ->			int:







								'''simple docstring'''

								return (
								    AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)
								    if is_vision_available()
								    else None
								)






					@slow
					def A      (				self						)   ->			Dict:







								'''simple docstring'''

								__lowercase 					=   TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)

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

								# forward pass
								__lowercase 					=   model(**snake_case_ ,       training=snake_case_						)

								# verify the logits
								__lowercase 					=   tf.TensorShape((1, 1_0_0_0)						)
								self.assertEqual(outputs.logits.shape ,       snake_case_						)

								__lowercase 					=   tf.constant([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]						)

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






from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL

from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available
from .timesteps import (
    fastaa_timesteps,
    smartaa_timesteps,
    smartaa_timesteps,
    smartaaa_timesteps,
    smartaaa_timesteps,
    superaa_timesteps,
    superaa_timesteps,
    superaaa_timesteps,
)
@dataclass
class 	lowerCamelCase_       (				lowerCAmelCase__				):



					'''simple docstring'''







					__UpperCAmelCase            =				42
					__UpperCAmelCase            =				42
					__UpperCAmelCase            =				42


try:
	if not (is_transformers_available() and is_torch_available()):
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
	from .pipeline_if import IFPipeline
	from .pipeline_if_imgaimg import IFImgaImgPipeline
	from .pipeline_if_imgaimg_superresolution import IFImgaImgSuperResolutionPipeline
	from .pipeline_if_inpainting import IFInpaintingPipeline
	from .pipeline_if_inpainting_superresolution import IFInpaintingSuperResolutionPipeline
	from .pipeline_if_superresolution import IFSuperResolutionPipeline
	from .safety_checker import IFSafetyChecker
	from .watermark import IFWatermarker


