

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 		__magic_name__    :

   '''simple docstring'''




   def __init__(       self,					lowercase_,					lowercase_=13,					lowercase_=32,					lowercase_=1,					lowercase_=3,					lowercase_=16,					lowercase_=[1, 2, 1],					lowercase_=[2, 2, 4],					lowercase_=2,					lowercase_=2.0,					lowercase_=True,					lowercase_=0.0,					lowercase_=0.0,					lowercase_=0.1,					lowercase_="gelu",					lowercase_=False,					lowercase_=True,					lowercase_=0.02,					lowercase_=1E-5,					lowercase_=True,					lowercase_=None,					lowercase_=False,					lowercase_=2,					)							->					int:






     """simple docstring"""






     a__						=parent
     a__						=batch_size
     a__						=image_size
     a__						=patch_size
     a__						=num_channels
     a__						=embed_dim
     a__						=depths
     a__						=num_heads
     a__						=window_size
     a__						=mlp_ratio
     a__						=qkv_bias
     a__						=hidden_dropout_prob
     a__						=attention_probs_dropout_prob
     a__						=drop_path_rate
     a__						=hidden_act
     a__						=use_absolute_embeddings
     a__						=patch_norm
     a__						=layer_norm_eps
     a__						=initializer_range
     a__						=is_training
     a__						=scope
     a__						=use_labels
     a__						=upscale

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



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






     """simple docstring"""






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

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

     a__						=self.get_config()

     return config, pixel_values, labels



   def 				_UpperCAmelCase				(       self )							->					Tuple:






     """simple docstring"""






     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 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_,					lowercase_ )							->					List[str]:






     """simple docstring"""






     a__						=SwinaSRModel(config=lowercase_ )
     model.to(lowercase_ )
     model.eval()
     a__						=model(lowercase_ )

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



   def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_,					lowercase_ )							->					List[Any]:






     """simple docstring"""






     a__						=SwinaSRForImageSuperResolution(lowercase_ )
     model.to(lowercase_ )
     model.eval()
     a__						=model(lowercase_ )

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



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






     """simple docstring"""






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







@require_torch
class 		__magic_name__    (							lowerCamelCase__	, lowerCamelCase__	, unittest.TestCase							):

   '''simple docstring'''




   lowerCamelCase__				:			Dict												=     (SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
   lowerCamelCase__				:			Optional[int]												=     {'feature-extraction': SwinaSRModel} if is_torch_available() else {}

   lowerCamelCase__				:			str												=     False
   lowerCamelCase__				:			Any												=     False
   lowerCamelCase__				:			Dict												=     False
   lowerCamelCase__				:			int												=     False
   lowerCamelCase__				:			Any												=     False



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






     """simple docstring"""






     a__						=SwinaSRModelTester(self )
     a__						=ConfigTester(self,					config_class=lowercase_,					embed_dim=37 )



   def 				_UpperCAmelCase				(       self )							->					Any:






     """simple docstring"""






     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 )							->					Any:






     """simple docstring"""






     a__						=self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowercase_ )



   def 				_UpperCAmelCase				(       self )							->					Optional[int]:






     """simple docstring"""






     a__						=self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_super_resolution(*lowercase_ )



   @unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.''' )
   def 				_UpperCAmelCase				(       self )							->					Optional[Any]:






     """simple docstring"""






     pass



   @unittest.skip(reason='''Swin2SR does not use inputs_embeds''' )
   def 				_UpperCAmelCase				(       self )							->					Dict:






     """simple docstring"""






     pass



   @unittest.skip(reason='''Swin2SR does not support training yet''' )
   def 				_UpperCAmelCase				(       self )							->					List[Any]:






     """simple docstring"""






     pass



   @unittest.skip(reason='''Swin2SR does not support training yet''' )
   def 				_UpperCAmelCase				(       self )							->					Union[str, Any]:






     """simple docstring"""






     pass



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






     """simple docstring"""






     a__,   a__						=self.model_tester.prepare_config_and_inputs_for_common()

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



   def 				_UpperCAmelCase				(       self )							->					str:






     """simple docstring"""






     a__,   a__						=self.model_tester.prepare_config_and_inputs_for_common()

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

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



   @slow
   def 				_UpperCAmelCase				(       self )							->					Optional[int]:






     """simple docstring"""






     for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       a__						=SwinaSRModel.from_pretrained(lowercase_ )
       self.assertIsNotNone(lowercase_ )



   def 				_UpperCAmelCase				(       self )							->					Dict:






     """simple docstring"""






     a__,   a__						=self.model_tester.prepare_config_and_inputs_for_common()

     a__						=_config_zero_init(lowercase_ )
     for model_class in self.all_model_classes:
       a__						=model_class(config=lowercase_ )
       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 				_UpperCAmelCase				(       self )							->					Dict:






     """simple docstring"""






     a__,   a__						=self.model_tester.prepare_config_and_inputs_for_common()
     a__						=True

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

       # check that output_attentions also work using config
       del inputs_dict["output_attentions"]
       a__						=True
       a__						=config.window_size**2
       a__						=model_class(lowercase_ )
       model.to(lowercase_ )
       model.eval()
       with torch.no_grad():
         a__						=model(**self._prepare_for_class(lowercase_,					lowercase_ ) )
       a__						=outputs.attentions
       self.assertEqual(len(lowercase_ ),					lowercase_ )

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

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

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

       a__						=outputs.attentions

       self.assertEqual(len(lowercase_ ),					lowercase_ )

       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 		__magic_name__    (							unittest.TestCase							):

   '''simple docstring'''




   def 				_UpperCAmelCase				(       self )							->					int:






     """simple docstring"""






     a__						=SwinaSRImageProcessor()
     a__						=SwinaSRForImageSuperResolution.from_pretrained('''caidas/swin2SR-classical-sr-x2-64''' ).to(lowercase_ )

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

     # forward pass
     with torch.no_grad():
       a__						=model(**lowercase_ )

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



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

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available







@dataclass
# Copied from diffusers.pipelines.stable_diffusion.__init__.StableDiffusionPipelineOutput with Stable->Alt
class 		__magic_name__    (							lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__				:			Union[List[PIL.Image.Image], np.ndarray]
   lowerCamelCase__				:			Optional[List[bool]]


if is_transformers_available() and is_torch_available():
       from .modeling_roberta_series import RobertaSeriesModelWithTransformation
       from .pipeline_alt_diffusion import AltDiffusionPipeline
       from .pipeline_alt_diffusion_imgaimg import AltDiffusionImgaImgPipeline
