


'''simple docstring'''

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

 def __init__(			self			:						List[str],       a_			:						Optional[Any],       a_			:						Optional[int]=13,       a_			:						Any=32,       a_			:						List[Any]=1,       a_			:						List[str]=3,       a_			:						Dict=16,       a_			:						int=[1, 2, 1],       a_			:						Tuple=[2, 2, 4],       a_			:						Optional[Any]=2,       a_			:						str=2.0,       a_			:						List[Any]=True,       a_			:						str=0.0,       a_			:						Optional[Any]=0.0,       a_			:						Optional[int]=0.1,       a_			:						Tuple="gelu",       a_			:						List[str]=False,       a_			:						Union[str, Any]=True,       a_			:						Union[str, Any]=0.02,       a_			:						Tuple=1e-5,       a_			:						Union[str, Any]=True,       a_			:						List[Any]=None,       a_			:						List[Any]=False,       a_			:						Optional[Any]=2,       ):





    """simple docstring"""



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

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

 def 		lowercase_    (			self			:						List[Any]       ):





    """simple docstring"""



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

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

    UpperCamelCase__			    =    self.get_config()

    return config, pixel_values, labels

 def 		lowercase_    (			self			:						List[str]       ):





    """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 		lowercase_    (			self			:						Tuple,       a_			:						Dict,       a_			:						Optional[Any],       a_			:						int       ):





    """simple docstring"""



    UpperCamelCase__			    =    SwinaSRModel(config=a_       )
    model.to(a_       )
    model.eval()
    UpperCamelCase__			    =    model(a_       )

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

 def 		lowercase_    (			self			:						Union[str, Any],       a_			:						Union[str, Any],       a_			:						Union[str, Any],       a_			:						str       ):





    """simple docstring"""



    UpperCamelCase__			    =    SwinaSRForImageSuperResolution(a_       )
    model.to(a_       )
    model.eval()
    UpperCamelCase__			    =    model(a_       )

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

 def 		lowercase_    (			self			:						Optional[Any]       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.prepare_config_and_inputs()
    UpperCamelCase__    ,		UpperCamelCase__    ,		UpperCamelCase__			    =    config_and_inputs
    UpperCamelCase__			    =    {"pixel_values": pixel_values}
    return config, inputs_dict







@require_torch
class 			UpperCAmelCase			(							SCREAMING_SNAKE_CASE__		,      SCREAMING_SNAKE_CASE__		,      unittest.TestCase):
 _lowerCamelCase			:       int            =       (SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
 _lowerCamelCase			:       str            =       {'feature-extraction': SwinaSRModel} if is_torch_available() else {}

 _lowerCamelCase			:       Tuple            =       False
 _lowerCamelCase			:       str            =       False
 _lowerCamelCase			:       int            =       False
 _lowerCamelCase			:       List[str]            =       False
 _lowerCamelCase			:       Tuple            =       False

 def 		lowercase_    (			self			:						List[str]       ):





    """simple docstring"""



    UpperCamelCase__			    =    SwinaSRModelTester(self       )
    UpperCamelCase__			    =    ConfigTester(self,       config_class=a_,       embed_dim=37       )

 def 		lowercase_    (			self			:						List[str]       ):





    """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 		lowercase_    (			self			:						List[Any]       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*a_       )

 def 		lowercase_    (			self			:						int       ):





    """simple docstring"""



    UpperCamelCase__			    =    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 		lowercase_    (			self			:						List[Any]       ):





    """simple docstring"""



    pass

 @unittest.skip(reason="Swin2SR does not use inputs_embeds"       )
 def 		lowercase_    (			self			:						List[str]       ):





    """simple docstring"""



    pass

 @unittest.skip(reason="Swin2SR does not support training yet"       )
 def 		lowercase_    (			self			:						Optional[int]       ):





    """simple docstring"""



    pass

 @unittest.skip(reason="Swin2SR does not support training yet"       )
 def 		lowercase_    (			self			:						Optional[int]       ):





    """simple docstring"""



    pass

 def 		lowercase_    (			self			:						Optional[Any]       ):





    """simple docstring"""



    UpperCamelCase__    ,		UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs_for_common()

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

 def 		lowercase_    (			self			:						int       ):





    """simple docstring"""



    UpperCamelCase__    ,		UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs_for_common()

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

       UpperCamelCase__			    =    ["pixel_values"]
       self.assertListEqual(arg_names[:1],       a_       )

 @slow
 def 		lowercase_    (			self			:						Dict       ):





    """simple docstring"""



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

 def 		lowercase_    (			self			:						List[str]       ):





    """simple docstring"""



    UpperCamelCase__    ,		UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs_for_common()

    UpperCamelCase__			    =    _config_zero_init(a_       )
    for model_class in self.all_model_classes:
       UpperCamelCase__			    =    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 		lowercase_    (			self			:						Any       ):





    """simple docstring"""



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

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

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

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

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

       UpperCamelCase__			    =    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 			UpperCAmelCase			(							unittest.TestCase):

 def 		lowercase_    (			self			:						Optional[int]       ):





    """simple docstring"""



    UpperCamelCase__			    =    SwinaSRImageProcessor()
    UpperCamelCase__			    =    SwinaSRForImageSuperResolution.from_pretrained("caidas/swin2SR-classical-sr-x2-64"       ).to(a_       )

    UpperCamelCase__			    =    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
    UpperCamelCase__			    =    processor(images=a_,       return_tensors="pt"       ).to(a_       )

    # forward pass
    with torch.no_grad():
       UpperCamelCase__			    =    model(**a_       )

    # verify the logits
    UpperCamelCase__			    =    torch.Size([1, 3, 976, 1296]       )
    self.assertEqual(outputs.reconstruction.shape,       a_       )
    UpperCamelCase__			    =    torch.tensor(
        [[0.5_458, 0.5_546, 0.5_638], [0.5_526, 0.5_565, 0.5_651], [0.5_396, 0.5_426, 0.5_621]]       ).to(a_       )
    self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3],       a_,       atol=1e-4       )       )

'''simple docstring'''





import shutil
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from transformers import SpeechaTextTokenizer, is_speech_available
from transformers.models.speech_to_text.tokenization_speech_to_text import VOCAB_FILES_NAMES, save_json
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, require_torchaudio
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_speech_to_text import floats_list


if is_speech_available():
     from transformers import SpeechaTextFeatureExtractor, SpeechaTextProcessor


A							     = get_tests_dir("fixtures/test_sentencepiece.model")



@require_torch
@require_torchaudio
@require_sentencepiece
class 			lowerCAmelCase__ (							unittest.TestCase							):



  '''simple docstring'''






  def 		_lowerCamelCase						(self	:			List[str]     ) ->							List[str]:
        snake_case_    							=				tempfile.mkdtemp()

        snake_case_    							=				["<s>", "<pad>", "</s>", "<unk>", "▁This", "▁is", "▁a", "▁t", "est"]
        snake_case_    							=				dict(zip(lowerCAmelCase_						,			range(len(lowerCAmelCase_     )     )     )     )
        snake_case_    							=				Path(self.tmpdirname     )
        save_json(lowerCAmelCase_						,			save_dir / VOCAB_FILES_NAMES["vocab_file"]     )
        if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
              copyfile(lowerCAmelCase_						,			save_dir / VOCAB_FILES_NAMES["spm_file"]     )

        snake_case_    							=				SpeechaTextTokenizer.from_pretrained(self.tmpdirname     )
        tokenizer.save_pretrained(self.tmpdirname     )

        snake_case_    							=				{
            "feature_size": 24,
            "num_mel_bins": 24,
            "padding_value": 0.0,
            "sampling_rate": 1_60_00,
            "return_attention_mask": False,
            "do_normalize": True,
        }
        save_json(lowerCAmelCase_						,			save_dir / FEATURE_EXTRACTOR_NAME     )

  def 		_lowerCamelCase						(self	:			Dict						,			**lowerCAmelCase_	:			Any     ) ->							Union[str, Any]:
        return SpeechaTextTokenizer.from_pretrained(self.tmpdirname						,			**lowerCAmelCase_     )

  def 		_lowerCamelCase						(self	:			List[str]						,			**lowerCAmelCase_	:			List[str]     ) ->							Any:
        return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname						,			**lowerCAmelCase_     )

  def 		_lowerCamelCase						(self	:			int     ) ->							str:
        shutil.rmtree(self.tmpdirname     )

  def 		_lowerCamelCase						(self	:			List[Any]     ) ->							Optional[Any]:
        snake_case_    							=				self.get_tokenizer()
        snake_case_    							=				self.get_feature_extractor()

        snake_case_    							=				SpeechaTextProcessor(tokenizer=lowerCAmelCase_						,			feature_extractor=lowerCAmelCase_     )

        processor.save_pretrained(self.tmpdirname     )
        snake_case_    							=				SpeechaTextProcessor.from_pretrained(self.tmpdirname     )

        self.assertEqual(processor.tokenizer.get_vocab()						,			tokenizer.get_vocab()     )
        self.assertIsInstance(processor.tokenizer						,			lowerCAmelCase_     )

        self.assertEqual(processor.feature_extractor.to_json_string()						,			feature_extractor.to_json_string()     )
        self.assertIsInstance(processor.feature_extractor						,			lowerCAmelCase_     )

  def 		_lowerCamelCase						(self	:			str     ) ->							int:
        snake_case_    							=				SpeechaTextProcessor(
            tokenizer=self.get_tokenizer()						,			feature_extractor=self.get_feature_extractor()     )
        processor.save_pretrained(self.tmpdirname     )

        snake_case_    							=				self.get_tokenizer(bos_token="(BOS)"						,			eos_token="(EOS)"     )
        snake_case_    							=				self.get_feature_extractor(do_normalize=lowerCAmelCase_						,			padding_value=1.0     )

        snake_case_    							=				SpeechaTextProcessor.from_pretrained(
            self.tmpdirname						,			bos_token="(BOS)"						,			eos_token="(EOS)"						,			do_normalize=lowerCAmelCase_						,			padding_value=1.0     )

        self.assertEqual(processor.tokenizer.get_vocab()						,			tokenizer_add_kwargs.get_vocab()     )
        self.assertIsInstance(processor.tokenizer						,			lowerCAmelCase_     )

        self.assertEqual(processor.feature_extractor.to_json_string()						,			feature_extractor_add_kwargs.to_json_string()     )
        self.assertIsInstance(processor.feature_extractor						,			lowerCAmelCase_     )

  def 		_lowerCamelCase						(self	:			Tuple     ) ->							Optional[Any]:
        snake_case_    							=				self.get_feature_extractor()
        snake_case_    							=				self.get_tokenizer()

        snake_case_    							=				SpeechaTextProcessor(tokenizer=lowerCAmelCase_						,			feature_extractor=lowerCAmelCase_     )

        snake_case_    							=				floats_list((3, 10_00)     )

        snake_case_    							=				feature_extractor(lowerCAmelCase_						,			return_tensors="np"     )
        snake_case_    							=				processor(lowerCAmelCase_						,			return_tensors="np"     )

        for key in input_feat_extract.keys():
              self.assertAlmostEqual(input_feat_extract[key].sum()						,			input_processor[key].sum()						,			delta=1E-2     )

  def 		_lowerCamelCase						(self	:			Union[str, Any]     ) ->							int:
        snake_case_    							=				self.get_feature_extractor()
        snake_case_    							=				self.get_tokenizer()

        snake_case_    							=				SpeechaTextProcessor(tokenizer=lowerCAmelCase_						,			feature_extractor=lowerCAmelCase_     )

        snake_case_    							=				"This is a test string"

        snake_case_    							=				processor(text=lowerCAmelCase_     )

        snake_case_    							=				tokenizer(lowerCAmelCase_     )

        for key in encoded_tok.keys():
              self.assertListEqual(encoded_tok[key]						,			encoded_processor[key]     )

  def 		_lowerCamelCase						(self	:			Union[str, Any]     ) ->							int:
        snake_case_    							=				self.get_feature_extractor()
        snake_case_    							=				self.get_tokenizer()

        snake_case_    							=				SpeechaTextProcessor(tokenizer=lowerCAmelCase_						,			feature_extractor=lowerCAmelCase_     )

        snake_case_    							=				[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

        snake_case_    							=				processor.batch_decode(lowerCAmelCase_     )
        snake_case_    							=				tokenizer.batch_decode(lowerCAmelCase_     )

        self.assertListEqual(lowerCAmelCase_						,			lowerCAmelCase_     )


  def 		_lowerCamelCase						(self	:			int     ) ->							int:
        snake_case_    							=				self.get_feature_extractor()
        snake_case_    							=				self.get_tokenizer()

        snake_case_    							=				SpeechaTextProcessor(tokenizer=lowerCAmelCase_						,			feature_extractor=lowerCAmelCase_     )

        self.assertListEqual(
            processor.model_input_names						,			feature_extractor.model_input_names						,			msg="`processor` and `feature_extractor` model input names do not match"						,			)

