


import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPImageProcessor, CLIPVisionConfig

from diffusers import AutoencoderKL, PaintByExamplePipeline, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.paint_by_example import PaintByExampleImageEncoder
from diffusers.utils import floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import IMAGE_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, IMAGE_GUIDED_IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()



class 							lowercase__(						__lowercase			,							unittest.TestCase			):






      '''simple docstring'''







      snake_case__       =					PaintByExamplePipeline
      snake_case__       =					IMAGE_GUIDED_IMAGE_INPAINTING_PARAMS
      snake_case__       =					IMAGE_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
      snake_case__       =					frozenset([]			)  # TO_DO: update the image_prams once refactored VaeImageProcessor.preprocess




      def    UpperCAmelCase							(		self)					->						Dict:







         """simple docstring"""







         torch.manual_seed(0)
         UpperCamelCase__ :			List[str] 						=UNetaDConditionModel(
             block_out_channels=(32, 64)   ,			layers_per_block=2   ,			sample_size=32   ,			in_channels=9   ,			out_channels=4   ,			down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")   ,			up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")   ,			cross_attention_dim=32   ,			)
         UpperCamelCase__ :			Optional[int] 						=PNDMScheduler(skip_prk_steps=__A)
         torch.manual_seed(0)
         UpperCamelCase__ :			Optional[int] 						=AutoencoderKL(
             block_out_channels=[32, 64]   ,			in_channels=3   ,			out_channels=3   ,			down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]   ,			up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]   ,			latent_channels=4   ,			)
         torch.manual_seed(0)
         UpperCamelCase__ :			List[Any] 						=CLIPVisionConfig(
             hidden_size=32   ,			projection_dim=32   ,			intermediate_size=37   ,			layer_norm_eps=1E-05   ,			num_attention_heads=4   ,			num_hidden_layers=5   ,			image_size=32   ,			patch_size=4   ,			)
         UpperCamelCase__ :			Union[str, Any] 						=PaintByExampleImageEncoder(__A   ,			proj_size=32)
         UpperCamelCase__ :			List[str] 						=CLIPImageProcessor(crop_size=32   ,			size=32)

         UpperCamelCase__ :			int 						={
             "unet": unet,
             "scheduler": scheduler,
             "vae": vae,
             "image_encoder": image_encoder,
             "safety_checker": None,
             "feature_extractor": feature_extractor,
         }
         return components




      def    UpperCAmelCase							(		self   ,			__SCREAMING_SNAKE_CASE)					->						List[Any]:







         """simple docstring"""







         UpperCamelCase__ :			Optional[int] 						=np.array(image.convert("RGB"))
         UpperCamelCase__ :			List[str] 						=image[None].transpose(0   ,			3   ,			1   ,			2)
         UpperCamelCase__ :			Optional[Any] 						=torch.from_numpy(__A).to(dtype=torch.floataa) / 1_27.5 - 1.0
         return image




      def    UpperCAmelCase							(		self   ,			__SCREAMING_SNAKE_CASE="cpu"   ,			__SCREAMING_SNAKE_CASE=0)					->						Dict:







         """simple docstring"""







         UpperCamelCase__ :			Optional[Any] 						=floats_tensor((1, 3, 32, 32)   ,			rng=random.Random(__A)).to(__A)
         UpperCamelCase__ :			Any 						=image.cpu().permute(0   ,			2   ,			3   ,			1)[0]
         UpperCamelCase__ :			Dict 						=Image.fromarray(np.uinta(__A)).convert("RGB").resize((64, 64))
         UpperCamelCase__ :			int 						=Image.fromarray(np.uinta(image + 4)).convert("RGB").resize((64, 64))
         UpperCamelCase__ :			Any 						=Image.fromarray(np.uinta(__A)).convert("RGB").resize((32, 32))

         if str(__A).startswith("mps"):
            UpperCamelCase__ :			int 						=torch.manual_seed(__A)
         else:
            UpperCamelCase__ :			int 						=torch.Generator(device=__A).manual_seed(__A)
         UpperCamelCase__ :			List[Any] 						={
             "example_image": example_image,
             "image": init_image,
             "mask_image": mask_image,
             "generator": generator,
             "num_inference_steps": 2,
             "guidance_scale": 6.0,
             "output_type": "numpy",
         }
         return inputs




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







         """simple docstring"""







         UpperCamelCase__ :			List[Any] 						=self.get_dummy_components()

         # make sure here that pndm scheduler skips prk
         UpperCamelCase__ :			Any 						=PaintByExamplePipeline(**__A)
         UpperCamelCase__ :			int 						=pipe.to("cpu")
         pipe.set_progress_bar_config(disable=__A)

         UpperCamelCase__ :			Tuple 						=self.get_dummy_inputs()
         UpperCamelCase__ :			List[Any] 						=pipe(**__A)
         UpperCamelCase__ :			Tuple 						=output.images

         UpperCamelCase__ :			Any 						=image[0, -3:, -3:, -1]

         assert image.shape == (1, 64, 64, 3)
         UpperCamelCase__ :			int 						=np.array([0.46_86, 0.56_87, 0.40_07, 0.52_18, 0.57_41, 0.44_82, 0.49_40, 0.46_29, 0.45_03])

         assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2




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







         """simple docstring"""







         UpperCamelCase__ :			str 						="cpu"
         UpperCamelCase__ :			int 						=self.get_dummy_inputs()
         inputs.pop("mask_image")
         UpperCamelCase__ :			Tuple 						=self.convert_to_pt(inputs.pop("image"))
         UpperCamelCase__ :			int 						=image.clamp(0   ,			1) / 2

         # make sure here that pndm scheduler skips prk
         UpperCamelCase__ :			List[str] 						=PaintByExamplePipeline(**self.get_dummy_components())
         UpperCamelCase__ :			int 						=pipe.to(__A)
         pipe.set_progress_bar_config(disable=__A)

         UpperCamelCase__ :			Optional[int] 						=pipe(image=__A   ,			mask_image=mask_image[:, 0]   ,			**__A)
         UpperCamelCase__ :			List[Any] 						=output.images

         UpperCamelCase__ :			List[str] 						=image.cpu().permute(0   ,			2   ,			3   ,			1)[0]
         UpperCamelCase__ :			List[Any] 						=mask_image.cpu().permute(0   ,			2   ,			3   ,			1)[0]

         UpperCamelCase__ :			Optional[int] 						=Image.fromarray(np.uinta(__A)).convert("RGB")
         UpperCamelCase__ :			Optional[Any] 						=Image.fromarray(np.uinta(__A)).convert("RGB")

         UpperCamelCase__ :			str 						=pipe(**self.get_dummy_inputs())
         UpperCamelCase__ :			Dict 						=output.images

         assert out_a.shape == (1, 64, 64, 3)
         assert np.abs(out_a.flatten() - out_a.flatten()).max() < 5E-2




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







         """simple docstring"""







         super().test_inference_batch_single_identical(expected_max_diff=3E-3)




@slow
@require_torch_gpu
class 							lowercase__(						unittest.TestCase			):






      '''simple docstring'''







      def    UpperCAmelCase							(		self)					->						Any:







         """simple docstring"""







         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()




      def    UpperCAmelCase							(		self)					->						str:







         """simple docstring"""







         UpperCamelCase__ :			Tuple 						=load_image(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
             "/paint_by_example/dog_in_bucket.png")
         UpperCamelCase__ :			Optional[Any] 						=load_image(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
             "/paint_by_example/mask.png")
         UpperCamelCase__ :			Dict 						=load_image(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
             "/paint_by_example/panda.jpg")

         UpperCamelCase__ :			Union[str, Any] 						=PaintByExamplePipeline.from_pretrained("Fantasy-Studio/Paint-by-Example")
         UpperCamelCase__ :			Tuple 						=pipe.to(__A)
         pipe.set_progress_bar_config(disable=__A)

         UpperCamelCase__ :			Dict 						=torch.manual_seed(3_21)
         UpperCamelCase__ :			Any 						=pipe(
             image=__A   ,			mask_image=__A   ,			example_image=__A   ,			generator=__A   ,			guidance_scale=5.0   ,			num_inference_steps=50   ,			output_type="np"   ,			)

         UpperCamelCase__ :			Union[str, Any] 						=output.images

         UpperCamelCase__ :			Union[str, Any] 						=image[0, -3:, -3:, -1]

         assert image.shape == (1, 5_12, 5_12, 3)
         UpperCamelCase__ :			List[Any] 						=np.array([0.48_34, 0.48_11, 0.48_74, 0.51_22, 0.50_81, 0.51_44, 0.52_91, 0.52_90, 0.53_74])

         assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2


'''simple docstring'''

from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import SwinConfig
from transformers.testing_utils import require_tf, require_vision, slow, to_atuple
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.models.swin.modeling_tf_swin import (
							    TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
							    TFSwinForImageClassification,
							    TFSwinForMaskedImageModeling,
							    TFSwinModel,
							)


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor
class 	SCREAMING_SNAKE_CASE      :







		"""simple docstring"""






		def __init__( self		,    __A		,    __A=13		,    __A=32		,    __A=2		,    __A=3		,    __A=16		,    __A=[1, 2, 1]		,    __A=[2, 2, 4]		,    __A=2		,    __A=2.0		,    __A=True		,    __A=0.0		,    __A=0.0		,    __A=0.1		,    __A="gelu"		,    __A=False		,    __A=True		,    __A=0.02		,    __A=1E-5		,    __A=True		,    __A=None		,    __A=True		,    __A=10		,    __A=8		,    )			->  None:
								_lowerCAmelCase					    =parent
								_lowerCAmelCase					    =batch_size
								_lowerCAmelCase					    =image_size
								_lowerCAmelCase					    =patch_size
								_lowerCAmelCase					    =num_channels
								_lowerCAmelCase					    =embed_dim
								_lowerCAmelCase					    =depths
								_lowerCAmelCase					    =num_heads
								_lowerCAmelCase					    =window_size
								_lowerCAmelCase					    =mlp_ratio
								_lowerCAmelCase					    =qkv_bias
								_lowerCAmelCase					    =hidden_dropout_prob
								_lowerCAmelCase					    =attention_probs_dropout_prob
								_lowerCAmelCase					    =drop_path_rate
								_lowerCAmelCase					    =hidden_act
								_lowerCAmelCase					    =use_absolute_embeddings
								_lowerCAmelCase					    =patch_norm
								_lowerCAmelCase					    =layer_norm_eps
								_lowerCAmelCase					    =initializer_range
								_lowerCAmelCase					    =is_training
								_lowerCAmelCase					    =scope
								_lowerCAmelCase					    =use_labels
								_lowerCAmelCase					    =type_sequence_label_size
								_lowerCAmelCase					    =encoder_stride






		def 		UpperCamelCase__							( self					)			->  Any:
								_lowerCAmelCase					    =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

								_lowerCAmelCase					    =self.get_config()

								return config, pixel_values, labels






		def 		UpperCamelCase__							( self					)			->  List[str]:
								return SwinConfig(
								    image_size=self.image_size		,    patch_size=self.patch_size		,    num_channels=self.num_channels		,    embed_dim=self.embed_dim		,    depths=self.depths		,    num_heads=self.num_heads		,    window_size=self.window_size		,    mlp_ratio=self.mlp_ratio		,    qkv_bias=self.qkv_bias		,    hidden_dropout_prob=self.hidden_dropout_prob		,    attention_probs_dropout_prob=self.attention_probs_dropout_prob		,    drop_path_rate=self.drop_path_rate		,    hidden_act=self.hidden_act		,    use_absolute_embeddings=self.use_absolute_embeddings		,    path_norm=self.patch_norm		,    layer_norm_eps=self.layer_norm_eps		,    initializer_range=self.initializer_range		,    encoder_stride=self.encoder_stride		,    )






		def 		UpperCamelCase__							( self		,    __A		,    __A		,    __A					)			->  str:
								_lowerCAmelCase					    =TFSwinModel(config=__A					)
								_lowerCAmelCase					    =model(__A					)

								_lowerCAmelCase					    =((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
								_lowerCAmelCase					    =int(config.embed_dim * 2 ** (len(config.depths					) - 1)					)

								self.parent.assertEqual(result.last_hidden_state.shape		,    (self.batch_size, expected_seq_len, expected_dim)					)






		def 		UpperCamelCase__							( self		,    __A		,    __A		,    __A					)			->  List[Any]:
								_lowerCAmelCase					    =TFSwinForMaskedImageModeling(config=__A					)
								_lowerCAmelCase					    =model(__A					)
								self.parent.assertEqual(
								    result.logits.shape		,    (self.batch_size, self.num_channels, self.image_size, self.image_size)					)

								# test greyscale images
								_lowerCAmelCase					    =1
								_lowerCAmelCase					    =TFSwinForMaskedImageModeling(__A					)

								_lowerCAmelCase					    =floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
								_lowerCAmelCase					    =model(__A					)
								self.parent.assertEqual(result.logits.shape		,    (self.batch_size, 1, self.image_size, self.image_size)					)






		def 		UpperCamelCase__							( self		,    __A		,    __A		,    __A					)			->  int:
								_lowerCAmelCase					    =self.type_sequence_label_size
								_lowerCAmelCase					    =TFSwinForImageClassification(__A					)
								_lowerCAmelCase					    =model(__A		,    labels=__A					)
								self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.type_sequence_label_size)					)

								# test greyscale images
								_lowerCAmelCase					    =1
								_lowerCAmelCase					    =TFSwinForImageClassification(__A					)
								_lowerCAmelCase					    =floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
								_lowerCAmelCase					    =model(__A					)
								self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.type_sequence_label_size)					)






		def 		UpperCamelCase__							( self					)			->  int:
								_lowerCAmelCase					    =self.prepare_config_and_inputs()
								_lowerCAmelCase    ,					_lowerCAmelCase    ,					_lowerCAmelCase					    =config_and_inputs
								_lowerCAmelCase					    ={'pixel_values': pixel_values}
								return config, inputs_dict

@require_tf
class 	SCREAMING_SNAKE_CASE      (    __lowercase     ,      __lowercase     ,      unittest.TestCase):







		"""simple docstring"""
		lowercase :   Tuple							=				(
		    (
		        TFSwinModel,
		        TFSwinForImageClassification,
		        TFSwinForMaskedImageModeling,
		    )
		    if is_tf_available()
		    else ()
		)
		lowercase :   int							=				(
		    {'feature-extraction': TFSwinModel, 'image-classification': TFSwinForImageClassification}
		    if is_tf_available()
		    else {}
		)

		lowercase :   Union[str, Any]							=				False
		lowercase :   Dict							=				False
		lowercase :   Optional[Any]							=				False
		lowercase :   Optional[Any]							=				False






		def 		UpperCamelCase__							( self					)			->  Dict:
								_lowerCAmelCase					    =TFSwinModelTester(self					)
								_lowerCAmelCase					    =ConfigTester(self		,    config_class=__A		,    embed_dim=37					)






		def 		UpperCamelCase__							( self					)			->  int:
								self.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()






		def 		UpperCamelCase__							( self					)			->  Tuple:
								return






		def 		UpperCamelCase__							( self					)			->  int:
								_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__A					)






		def 		UpperCamelCase__							( self					)			->  Dict:
								_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_image_modeling(*__A					)






		def 		UpperCamelCase__							( self					)			->  int:
								_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*__A					)






		@unittest.skip(reason='Swin does not use inputs_embeds'					)
		def 		UpperCamelCase__							( self					)			->  List[str]:
								pass






		def 		UpperCamelCase__							( self					)			->  Dict:
								_lowerCAmelCase    ,					_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
														_lowerCAmelCase					    =model_class(__A					)
														self.assertIsInstance(model.get_input_embeddings()		,    tf.keras.layers.Layer					)
														_lowerCAmelCase					    =model.get_output_embeddings()
														self.assertTrue(x is None or isinstance(__A		,    tf.keras.layers.Dense					)					)






		def 		UpperCamelCase__							( self					)			->  Tuple:
								_lowerCAmelCase    ,					_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs_for_common()

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

														_lowerCAmelCase					    =['pixel_values']
														self.assertListEqual(arg_names[:1]		,    __A					)






		def 		UpperCamelCase__							( self					)			->  str:
								_lowerCAmelCase    ,					_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs_for_common()
								_lowerCAmelCase					    =True

								for model_class in self.all_model_classes:
														_lowerCAmelCase					    =True
														_lowerCAmelCase					    =False
														_lowerCAmelCase					    =True
														_lowerCAmelCase					    =model_class(__A					)
														_lowerCAmelCase					    =model(**self._prepare_for_class(__A		,    __A					)					)
														_lowerCAmelCase					    =outputs.attentions
														_lowerCAmelCase					    =len(self.model_tester.depths					)
														self.assertEqual(len(__A					)		,    __A					)

														# check that output_attentions also work using config
														del inputs_dict["output_attentions"]
														_lowerCAmelCase					    =True
														_lowerCAmelCase					    =config.window_size**2
														_lowerCAmelCase					    =model_class(__A					)
														_lowerCAmelCase					    =model(**self._prepare_for_class(__A		,    __A					)					)
														_lowerCAmelCase					    =outputs.attentions
														self.assertEqual(len(__A					)		,    __A					)

														self.assertListEqual(
														    list(attentions[0].shape[-3:]					)		,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,    )
														_lowerCAmelCase					    =len(__A					)

														# Check attention is always last and order is fine
														_lowerCAmelCase					    =True
														_lowerCAmelCase					    =True
														_lowerCAmelCase					    =model_class(__A					)
														_lowerCAmelCase					    =model(**self._prepare_for_class(__A		,    __A					)					)

														if hasattr(self.model_tester		,    'num_hidden_states_types'					):
																				_lowerCAmelCase					    =self.model_tester.num_hidden_states_types
														else:
																				# also another +1 for reshaped_hidden_states
																				_lowerCAmelCase					    =2
														self.assertEqual(out_len + added_hidden_states		,    len(__A					)					)

														_lowerCAmelCase					    =outputs.attentions

														self.assertEqual(len(__A					)		,    __A					)

														self.assertListEqual(
														    list(self_attentions[0].shape[-3:]					)		,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,    )






		def 		UpperCamelCase__							( self		,    __A		,    __A		,    __A		,    __A					)			->  Union[str, Any]:
								_lowerCAmelCase					    =model_class(__A					)
								_lowerCAmelCase					    =model(**self._prepare_for_class(__A		,    __A					)					)
								_lowerCAmelCase					    =outputs.hidden_states

								_lowerCAmelCase					    =getattr(
								    self.model_tester		,    'expected_num_hidden_layers'		,    len(self.model_tester.depths					) + 1					)
								self.assertEqual(len(__A					)		,    __A					)

								# Swin has a different seq_length
								_lowerCAmelCase					    =to_atuple(config.patch_size					)

								_lowerCAmelCase					    =(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

								self.assertListEqual(
								    list(hidden_states[0].shape[-2:]					)		,    [num_patches, self.model_tester.embed_dim]		,    )

								_lowerCAmelCase					    =outputs.reshaped_hidden_states
								self.assertEqual(len(__A					)		,    __A					)

								_lowerCAmelCase    ,					_lowerCAmelCase    ,					_lowerCAmelCase    ,					_lowerCAmelCase					    =reshaped_hidden_states[0].shape

								_lowerCAmelCase					    =tf.reshape(reshaped_hidden_states[0]		,    (batch_size, num_channels, height * width)					)
								_lowerCAmelCase					    =tf.transpose(__A		,    (0, 2, 1)					)

								self.assertListEqual(
								    list(reshaped_hidden_states.shape[-2:]					)		,    [num_patches, self.model_tester.embed_dim]		,    )






		def 		UpperCamelCase__							( self					)			->  Optional[Any]:
								_lowerCAmelCase    ,					_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs_for_common()

								_lowerCAmelCase					    =to_atuple(self.model_tester.image_size					)

								for model_class in self.all_model_classes:
														_lowerCAmelCase					    =True
														self.check_hidden_states_output(__A		,    __A		,    __A		,    __A					)

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

														self.check_hidden_states_output(__A		,    __A		,    __A		,    __A					)






		def 		UpperCamelCase__							( self					)			->  Optional[Any]:
								_lowerCAmelCase    ,					_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs_for_common()
								_lowerCAmelCase					    =3

								_lowerCAmelCase					    =to_atuple(self.model_tester.image_size					)
								_lowerCAmelCase					    =to_atuple(config.patch_size					)

								_lowerCAmelCase					    =image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
								_lowerCAmelCase					    =image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

								for model_class in self.all_model_classes:
														_lowerCAmelCase					    =True
														self.check_hidden_states_output(__A		,    __A		,    __A		,    (padded_height, padded_width)					)

														# check that output_hidden_states also work using config
														del inputs_dict["output_hidden_states"]
														_lowerCAmelCase					    =True
														self.check_hidden_states_output(__A		,    __A		,    __A		,    (padded_height, padded_width)					)






		@slow
		def 		UpperCamelCase__							( self					)			->  str:
								for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														_lowerCAmelCase					    =TFSwinModel.from_pretrained(__A					)
														self.assertIsNotNone(__A					)

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







		"""simple docstring"""






		@cached_property
		def 		UpperCamelCase__							( self					)			->  List[str]:
								return (
								    AutoImageProcessor.from_pretrained('microsoft/swin-tiny-patch4-window7-224'					)
								    if is_vision_available()
								    else None
								)






		@slow
		def 		UpperCamelCase__							( self					)			->  List[str]:
								_lowerCAmelCase					    =TFSwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224'					)
								_lowerCAmelCase					    =self.default_image_processor

								_lowerCAmelCase					    =Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'					)
								_lowerCAmelCase					    =image_processor(images=__A		,    return_tensors='tf'					)

								# forward pass
								_lowerCAmelCase					    =model(__A					)

								# verify the logits
								_lowerCAmelCase					    =tf.TensorShape((1, 1000)					)
								self.assertEqual(outputs.logits.shape		,    __A					)
								_lowerCAmelCase					    =tf.constant([-0.0_948, -0.6_454, -0.0_921]					)
								self.assertTrue(np.allclose(outputs.logits[0, :3]		,    __A		,    atol=1E-4					)					)





