
import inspect
import unittest

from transformers import SwinaSRConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch
							from torch import nn

							from transformers import SwinaSRForImageSuperResolution, SwinaSRModel
							from transformers.models.swinasr.modeling_swinasr import SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
							from PIL import Image

							from transformers import SwinaSRImageProcessor







class 							lowercase						:




							def __init__(							self  ,A__  ,A__=1_3  ,A__=3_2  ,A__=1  ,A__=3  ,A__=1_6  ,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__=False  ,A__=2  ,):
												lowercase		      =		parent
												lowercase		      =		batch_size
												lowercase		      =		image_size
												lowercase		      =		patch_size
												lowercase		      =		num_channels
												lowercase		      =		embed_dim
												lowercase		      =		depths
												lowercase		      =		num_heads
												lowercase		      =		window_size
												lowercase		      =		mlp_ratio
												lowercase		      =		qkv_bias
												lowercase		      =		hidden_dropout_prob
												lowercase		      =		attention_probs_dropout_prob
												lowercase		      =		drop_path_rate
												lowercase		      =		hidden_act
												lowercase		      =		use_absolute_embeddings
												lowercase		      =		patch_norm
												lowercase		      =		layer_norm_eps
												lowercase		      =		initializer_range
												lowercase		      =		is_training
												lowercase		      =		scope
												lowercase		      =		use_labels
												lowercase		      =		upscale

												# here we set some attributes to make tests pass
												lowercase		      =		len(A__)
												lowercase		      =		embed_dim
												lowercase		      =		(image_size // patch_size) ** 2




							def 					A__ (							self):
												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.type_sequence_label_size)

												lowercase		      =		self.get_config()

												return config, pixel_values, labels




							def 					A__ (							self):
												return SwinaSRConfig(
												    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  ,upscale=self.upscale  ,)




							def 					A__ (							self  ,A__  ,A__  ,A__):
												lowercase		      =		SwinaSRModel(config=A__)
												model.to(A__)
												model.eval()
												lowercase		      =		model(A__)

												self.parent.assertEqual(
												    result.last_hidden_state.shape  ,(self.batch_size, self.embed_dim, self.image_size, self.image_size))




							def 					A__ (							self  ,A__  ,A__  ,A__):
												lowercase		      =		SwinaSRForImageSuperResolution(A__)
												model.to(A__)
												model.eval()
												lowercase		      =		model(A__)

												lowercase		      =		self.image_size * self.upscale
												self.parent.assertEqual(
												    result.reconstruction.shape  ,(self.batch_size, self.num_channels, expected_image_size, expected_image_size))





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







@require_torch
class 							lowercase						(   SCREAMING_SNAKE_CASE__			,    SCREAMING_SNAKE_CASE__			,    unittest.TestCase						):
							lowercase_			:			Optional[Any]			   =(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
							lowercase_			:			Tuple			   ={'''feature-extraction''': SwinaSRModel} if is_torch_available() else {}

							lowercase_			:			List[str]			   =False
							lowercase_			:			Dict			   =False
							lowercase_			:			Dict			   =False
							lowercase_			:			Optional[Any]			   =False
							lowercase_			:			Tuple			   =False




							def 					A__ (							self):
												lowercase		      =		SwinaSRModelTester(self)
												lowercase		      =		ConfigTester(self  ,config_class=A__  ,embed_dim=3_7)




							def 					A__ (							self):
												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 					A__ (							self):
												lowercase		      =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*A__)




							def 					A__ (							self):
												lowercase		      =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_super_resolution(*A__)




							@unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.''')
							def 					A__ (							self):
												pass




							@unittest.skip(reason='''Swin2SR does not use inputs_embeds''')
							def 					A__ (							self):
												pass




							@unittest.skip(reason='''Swin2SR does not support training yet''')
							def 					A__ (							self):
												pass




							@unittest.skip(reason='''Swin2SR does not support training yet''')
							def 					A__ (							self):
												pass




							def 					A__ (							self):
												lowercase      ,		lowercase		      =		self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																	lowercase		      =		model_class(A__)
																	self.assertIsInstance(model.get_input_embeddings()  ,(nn.Module))
																	lowercase		      =		model.get_output_embeddings()
																	self.assertTrue(x is None or isinstance(A__  ,nn.Linear))




							def 					A__ (							self):
												lowercase      ,		lowercase		      =		self.model_tester.prepare_config_and_inputs_for_common()

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

																	lowercase		      =		['''pixel_values''']
																	self.assertListEqual(arg_names[:1]  ,A__)




							@slow
							def 					A__ (							self):
												for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	lowercase		      =		SwinaSRModel.from_pretrained(A__)
																	self.assertIsNotNone(A__)




							def 					A__ (							self):
												lowercase      ,		lowercase		      =		self.model_tester.prepare_config_and_inputs_for_common()

												lowercase		      =		_config_zero_init(A__)
												for model_class in self.all_model_classes:
																	lowercase		      =		model_class(config=A__)
																	for name, param in model.named_parameters():
																						if "logit_scale" in name:
																											continue
																						if param.requires_grad:
																											self.assertIn(
																											    ((param.data.mean() * 1E9).round() / 1E9).item()  ,[0.0, 1.0]  ,msg=f'Parameter {name} of model {model_class} seems not properly initialized'  ,)





							def 					A__ (							self):
												lowercase      ,		lowercase		      =		self.model_tester.prepare_config_and_inputs_for_common()
												lowercase		      =		True

												for model_class in self.all_model_classes:
																	lowercase		      =		True
																	lowercase		      =		False
																	lowercase		      =		True
																	lowercase		      =		model_class(A__)
																	model.to(A__)
																	model.eval()
																	with torch.no_grad():
																						lowercase		      =		model(**self._prepare_for_class(A__  ,A__))
																	lowercase		      =		outputs.attentions
																	lowercase		      =		len(self.model_tester.depths)
																	self.assertEqual(len(A__)  ,A__)

																	# check that output_attentions also work using config
																	del inputs_dict["output_attentions"]
																	lowercase		      =		True
																	lowercase		      =		config.window_size**2
																	lowercase		      =		model_class(A__)
																	model.to(A__)
																	model.eval()
																	with torch.no_grad():
																						lowercase		      =		model(**self._prepare_for_class(A__  ,A__))
																	lowercase		      =		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]  ,)
																	lowercase		      =		len(A__)

																	# Check attention is always last and order is fine
																	lowercase		      =		True
																	lowercase		      =		True
																	lowercase		      =		model_class(A__)
																	model.to(A__)
																	model.eval()
																	with torch.no_grad():
																						lowercase		      =		model(**self._prepare_for_class(A__  ,A__))

																	self.assertEqual(out_len + 1  ,len(A__))

																	lowercase		      =		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]  ,)







@require_vision
@require_torch
@slow
class 							lowercase						(   unittest.TestCase						):




							def 					A__ (							self):
												lowercase		      =		SwinaSRImageProcessor()
												lowercase		      =		SwinaSRForImageSuperResolution.from_pretrained('''caidas/swin2SR-classical-sr-x2-64''').to(A__)

												lowercase		      =		Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
												lowercase		      =		processor(images=A__  ,return_tensors='''pt''').to(A__)

												# forward pass
												with torch.no_grad():
																	lowercase		      =		model(**A__)

												# verify the logits
												lowercase		      =		torch.Size([1, 3, 9_7_6, 1_2_9_6])
												self.assertEqual(outputs.reconstruction.shape  ,A__)
												lowercase		      =		torch.tensor(
												    [[0.5458, 0.5546, 0.5638], [0.5526, 0.5565, 0.5651], [0.5396, 0.5426, 0.5621]]).to(A__)
												self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3]  ,A__  ,atol=1E-4))






import unittest

import torch

from diffusers import DDIMScheduler, TextToVideoZeroPipeline
from diffusers.utils import load_pt, require_torch_gpu, slow

from ..test_pipelines_common import assert_mean_pixel_difference







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




							def 					A__ (							self):
												lowercase		      =		'''runwayml/stable-diffusion-v1-5'''
												lowercase		      =		TextToVideoZeroPipeline.from_pretrained(A__  ,torch_dtype=torch.floataa).to('''cuda''')
												lowercase		      =		DDIMScheduler.from_config(pipe.scheduler.config)
												lowercase		      =		torch.Generator(device='''cuda''').manual_seed(0)

												lowercase		      =		'''A bear is playing a guitar on Times Square'''
												lowercase		      =		pipe(prompt=A__  ,generator=A__).images

												lowercase		      =		load_pt(
												    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text-to-video/A bear is playing a guitar on Times Square.pt''')

												assert_mean_pixel_difference(A__  ,A__)




