code: 
  
  
  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 		_SCREAMING_SNAKE_CASE    :
  
  
       def __init__(     self       ,				A_       ,				A_=13       ,				A_=32       ,				A_=1       ,				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.0_2       ,				A_=1e-5       ,				A_=True       ,				A_=None       ,				A_=False       ,				A_=2       ,				):
         _UpperCAmelCase		:       Optional[int]       =    parent
         _UpperCAmelCase		:       str       =    batch_size
         _UpperCAmelCase		:       Any       =    image_size
         _UpperCAmelCase		:       Union[str, Any]       =    patch_size
         _UpperCAmelCase		:       Optional[Any]       =    num_channels
         _UpperCAmelCase		:       int       =    embed_dim
         _UpperCAmelCase		:       Optional[int]       =    depths
         _UpperCAmelCase		:       List[Any]       =    num_heads
         _UpperCAmelCase		:       Union[str, Any]       =    window_size
         _UpperCAmelCase		:       List[str]       =    mlp_ratio
         _UpperCAmelCase		:       Any       =    qkv_bias
         _UpperCAmelCase		:       List[Any]       =    hidden_dropout_prob
         _UpperCAmelCase		:       List[Any]       =    attention_probs_dropout_prob
         _UpperCAmelCase		:       Dict       =    drop_path_rate
         _UpperCAmelCase		:       List[Any]       =    hidden_act
         _UpperCAmelCase		:       int       =    use_absolute_embeddings
         _UpperCAmelCase		:       Union[str, Any]       =    patch_norm
         _UpperCAmelCase		:       Optional[int]       =    layer_norm_eps
         _UpperCAmelCase		:       int       =    initializer_range
         _UpperCAmelCase		:       List[str]       =    is_training
         _UpperCAmelCase		:       Tuple       =    scope
         _UpperCAmelCase		:       List[str]       =    use_labels
         _UpperCAmelCase		:       int       =    upscale
  
         # here we set some attributes to make tests pass
         _UpperCAmelCase		:       List[str]       =    len(A_						)
         _UpperCAmelCase		:       List[Any]       =    embed_dim
         _UpperCAmelCase		:       Optional[int]       =    (image_size // patch_size) ** 2
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       Union[str, Any]       =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)
  
         _UpperCAmelCase		:       int       =    None
         if self.use_labels:
           _UpperCAmelCase		:       Union[str, Any]       =    ids_tensor([self.batch_size]       ,				self.type_sequence_label_size						)
  
         _UpperCAmelCase		:       Tuple       =    self.get_config()
  
         return config, pixel_values, labels
  
  
       def 					__snake_case(     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 					__snake_case(     self       ,				A_       ,				A_       ,				A_						):
         _UpperCAmelCase		:       Dict       =    SwinaSRModel(config=A_						)
         model.to(A_						)
         model.eval()
         _UpperCAmelCase		:       Union[str, Any]       =    model(A_						)
  
         self.parent.assertEqual(
             result.last_hidden_state.shape       ,				(self.batch_size, self.embed_dim, self.image_size, self.image_size)						)
  
  
       def 					__snake_case(     self       ,				A_       ,				A_       ,				A_						):
         _UpperCAmelCase		:       str       =    SwinaSRForImageSuperResolution(A_						)
         model.to(A_						)
         model.eval()
         _UpperCAmelCase		:       Dict       =    model(A_						)
  
         _UpperCAmelCase		:       Dict       =    self.image_size * self.upscale
         self.parent.assertEqual(
             result.reconstruction.shape       ,				(self.batch_size, self.num_channels, expected_image_size, expected_image_size)						)
  
  
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       str       =    self.prepare_config_and_inputs()
         _UpperCAmelCase,_UpperCAmelCase,_UpperCAmelCase		:       Any       =    config_and_inputs
         _UpperCAmelCase		:       Any       =    {"""pixel_values""": pixel_values}
         return config, inputs_dict
  
  
  @require_torch
  class 		_SCREAMING_SNAKE_CASE    (	A       ,  A       ,  unittest.TestCase    ):
       __SCREAMING_SNAKE_CASE    				=						(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
       __SCREAMING_SNAKE_CASE    				=						{'''feature-extraction''': SwinaSRModel} if is_torch_available() else {}
  
       __SCREAMING_SNAKE_CASE    				=						False
       __SCREAMING_SNAKE_CASE    				=						False
       __SCREAMING_SNAKE_CASE    				=						False
       __SCREAMING_SNAKE_CASE    				=						False
       __SCREAMING_SNAKE_CASE    				=						False
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       Dict       =    SwinaSRModelTester(self						)
         _UpperCAmelCase		:       Tuple       =    ConfigTester(self       ,				config_class=A_       ,				embed_dim=37						)
  
  
       def 					__snake_case(     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 					__snake_case(     self						):
         _UpperCAmelCase		:       Dict       =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*A_						)
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       Optional[Any]       =    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 					__snake_case(     self						):
         pass
  
  
       @unittest.skip(reason="""Swin2SR does not use inputs_embeds"""						)
       def 					__snake_case(     self						):
         pass
  
  
       @unittest.skip(reason="""Swin2SR does not support training yet"""						)
       def 					__snake_case(     self						):
         pass
  
  
       @unittest.skip(reason="""Swin2SR does not support training yet"""						)
       def 					__snake_case(     self						):
         pass
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase,_UpperCAmelCase		:       Optional[int]       =    self.model_tester.prepare_config_and_inputs_for_common()
  
         for model_class in self.all_model_classes:
           _UpperCAmelCase		:       Any       =    model_class(A_						)
           self.assertIsInstance(model.get_input_embeddings()       ,				(nn.Module)						)
           _UpperCAmelCase		:       Any       =    model.get_output_embeddings()
           self.assertTrue(x is None or isinstance(A_       ,				nn.Linear						)						)
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase,_UpperCAmelCase		:       Tuple       =    self.model_tester.prepare_config_and_inputs_for_common()
  
         for model_class in self.all_model_classes:
           _UpperCAmelCase		:       int       =    model_class(A_						)
           _UpperCAmelCase		:       Tuple       =    inspect.signature(model.forward						)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           _UpperCAmelCase		:       Union[str, Any]       =    [*signature.parameters.keys()]
  
           _UpperCAmelCase		:       Tuple       =    ["""pixel_values"""]
           self.assertListEqual(arg_names[:1]       ,				A_						)
  
  
       @slow
       def 					__snake_case(     self						):
         for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _UpperCAmelCase		:       Optional[Any]       =    SwinaSRModel.from_pretrained(A_						)
           self.assertIsNotNone(A_						)
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase,_UpperCAmelCase		:       Any       =    self.model_tester.prepare_config_and_inputs_for_common()
  
         _UpperCAmelCase		:       Dict       =    _config_zero_init(A_						)
         for model_class in self.all_model_classes:
           _UpperCAmelCase		:       Any       =    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 					__snake_case(     self						):
         _UpperCAmelCase,_UpperCAmelCase		:       List[str]       =    self.model_tester.prepare_config_and_inputs_for_common()
         _UpperCAmelCase		:       Union[str, Any]       =    True
  
         for model_class in self.all_model_classes:
           _UpperCAmelCase		:       List[str]       =    True
           _UpperCAmelCase		:       Any       =    False
           _UpperCAmelCase		:       str       =    True
           _UpperCAmelCase		:       Any       =    model_class(A_						)
           model.to(A_						)
           model.eval()
           with torch.no_grad():
             _UpperCAmelCase		:       int       =    model(**self._prepare_for_class(A_       ,				A_						)						)
           _UpperCAmelCase		:       Union[str, Any]       =    outputs.attentions
           _UpperCAmelCase		:       Tuple       =    len(self.model_tester.depths						)
           self.assertEqual(len(A_						)       ,				A_						)
  
           # check that output_attentions also work using config
           del inputs_dict["output_attentions"]
           _UpperCAmelCase		:       List[Any]       =    True
           _UpperCAmelCase		:       Union[str, Any]       =    config.window_size**2
           _UpperCAmelCase		:       Dict       =    model_class(A_						)
           model.to(A_						)
           model.eval()
           with torch.no_grad():
             _UpperCAmelCase		:       Optional[int]       =    model(**self._prepare_for_class(A_       ,				A_						)						)
           _UpperCAmelCase		:       List[str]       =    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]       ,				)
           _UpperCAmelCase		:       Optional[int]       =    len(A_						)
  
           # Check attention is always last and order is fine
           _UpperCAmelCase		:       Dict       =    True
           _UpperCAmelCase		:       Any       =    True
           _UpperCAmelCase		:       Optional[Any]       =    model_class(A_						)
           model.to(A_						)
           model.eval()
           with torch.no_grad():
             _UpperCAmelCase		:       Any       =    model(**self._prepare_for_class(A_       ,				A_						)						)
  
           self.assertEqual(out_len + 1       ,				len(A_						)						)
  
           _UpperCAmelCase		:       Optional[Any]       =    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 		_SCREAMING_SNAKE_CASE    (	unittest.TestCase    ):
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       Optional[int]       =    SwinaSRImageProcessor()
         _UpperCAmelCase		:       List[str]       =    SwinaSRForImageSuperResolution.from_pretrained("""caidas/swin2SR-classical-sr-x2-64"""						).to(A_						)
  
         _UpperCAmelCase		:       int       =    Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
         _UpperCAmelCase		:       Dict       =    processor(images=A_       ,				return_tensors="""pt"""						).to(A_						)
  
         # forward pass
         with torch.no_grad():
           _UpperCAmelCase		:       Any       =    model(**A_						)
  
         # verify the logits
         _UpperCAmelCase		:       Optional[Any]       =    torch.Size([1, 3, 9_76, 12_96]						)
         self.assertEqual(outputs.reconstruction.shape       ,				A_						)
         _UpperCAmelCase		:       int       =    torch.tensor(
             [[0.5_4_5_8, 0.5_5_4_6, 0.5_6_3_8], [0.5_5_2_6, 0.5_5_6_5, 0.5_6_5_1], [0.5_3_9_6, 0.5_4_2_6, 0.5_6_2_1]]						).to(A_						)
         self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3]       ,				A_       ,				atol=1e-4						)						)
  
  
  
  
  
  
style_context: 
  
  
  import os
  
  import requests
  from bsa import BeautifulSoup
  from fake_useragent import UserAgent
  
  SCREAMING_SNAKE_CASE__				:    int         =    {'UserAgent': UserAgent().random}
  SCREAMING_SNAKE_CASE__				:    Tuple         =    'https://www.mywaifulist.moe/random'
  
  
  
  
  def       a__						(		snake_case__				:       str	,      snake_case__				:       str    ):
    _UpperCAmelCase		:       Any       =    requests.get(snake_case__	,      headers=snake_case__    )
    with open(snake_case__	,      """wb"""    ) as file:
      file.write(image.content    )
  
  
  
  
  def       a__						(		):
    _UpperCAmelCase		:       List[Any]       =    BeautifulSoup(requests.get(snake_case__	,      headers=snake_case__    ).text	,      """html.parser"""    )
    _UpperCAmelCase		:       Optional[int]       =    soup.find("""meta"""	,      attrs={"""property""": """og:title"""}    ).attrs["""content"""]
    _UpperCAmelCase		:       int       =    soup.find("""meta"""	,      attrs={"""property""": """og:image"""}    ).attrs["""content"""]
    _UpperCAmelCase		:       Any       =    soup.find("""p"""	,      id="""description"""    ).get_text()
    _UpperCAmelCase,_UpperCAmelCase		:       Dict       =    os.path.splitext(os.path.basename(snake_case__    )    )
    _UpperCAmelCase		:       Tuple       =    title.strip().replace(""" """	,      """_"""    )
    _UpperCAmelCase		:       Optional[Any]       =    f'''{image_title}{image_extension}'''
    save_image(snake_case__	,      snake_case__    )
    return (title, description, image_title)
  
  
  if __name__ == "__main__":
   SCREAMING_SNAKE_CASE__     ,				SCREAMING_SNAKE_CASE__     ,				SCREAMING_SNAKE_CASE__				:    Optional[int]         =    random_anime_character()
   print(F'{title}\n\n{desc}\n\nImage saved : {image_title}')
  
  
  
  
  
  