




import inspect
import unittest

from transformers import MobileViTVaConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
     import torch

     from transformers import MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel
     from transformers.models.mobilevitva.modeling_mobilevitva import (
         MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
         make_divisible,
     )


if is_vision_available():
     from PIL import Image

     from transformers import MobileViTImageProcessor





class 			__lowerCamelCase	(   UpperCamelCase__   ):




    """simple docstring"""

    def        a				(	self					:					Tuple       )				->	Optional[Any]:
     lowerCAmelCase__          =			self.config_class(**self.inputs_dict       )
     self.parent.assertTrue(hasattr(SCREAMING_SNAKE_CASE__       ,     "width_multiplier"       )       )






class 			__lowerCamelCase	:




    """simple docstring"""

    def __init__(	self					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					Optional[Any]       ,     SCREAMING_SNAKE_CASE__					:					Any=13       ,     SCREAMING_SNAKE_CASE__					:					Any=64       ,     SCREAMING_SNAKE_CASE__					:					int=2       ,     SCREAMING_SNAKE_CASE__					:					List[Any]=3       ,     SCREAMING_SNAKE_CASE__					:					Any="swish"       ,     SCREAMING_SNAKE_CASE__					:					Optional[int]=3       ,     SCREAMING_SNAKE_CASE__					:					str=32       ,     SCREAMING_SNAKE_CASE__					:					Union[str, Any]=0.1       ,     SCREAMING_SNAKE_CASE__					:					List[Any]=0.02       ,     SCREAMING_SNAKE_CASE__					:					List[str]=True       ,     SCREAMING_SNAKE_CASE__					:					List[str]=True       ,     SCREAMING_SNAKE_CASE__					:					Optional[int]=10       ,     SCREAMING_SNAKE_CASE__					:					Optional[Any]=None       ,     SCREAMING_SNAKE_CASE__					:					int=0.25       ,     SCREAMING_SNAKE_CASE__					:					Tuple=0.0       ,     SCREAMING_SNAKE_CASE__					:					Optional[int]=0.0       ,     )				->	Optional[int]:
     lowerCAmelCase__          =			parent
     lowerCAmelCase__          =			batch_size
     lowerCAmelCase__          =			image_size
     lowerCAmelCase__          =			patch_size
     lowerCAmelCase__          =			num_channels
     lowerCAmelCase__          =			make_divisible(512 * width_multiplier       ,     divisor=8       )
     lowerCAmelCase__          =			hidden_act
     lowerCAmelCase__          =			conv_kernel_size
     lowerCAmelCase__          =			output_stride
     lowerCAmelCase__          =			classifier_dropout_prob
     lowerCAmelCase__          =			use_labels
     lowerCAmelCase__          =			is_training
     lowerCAmelCase__          =			num_labels
     lowerCAmelCase__          =			initializer_range
     lowerCAmelCase__          =			scope
     lowerCAmelCase__          =			width_multiplier
     lowerCAmelCase__          =			ffn_dropout
     lowerCAmelCase__          =			attn_dropout


    def        a				(	self					:					Optional[int]       )				->	int:
     lowerCAmelCase__          =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

     lowerCAmelCase__          =			None
     lowerCAmelCase__          =			None
     if self.use_labels:
      lowerCAmelCase__          =			ids_tensor([self.batch_size]       ,     self.num_labels       )
      lowerCAmelCase__          =			ids_tensor([self.batch_size, self.image_size, self.image_size]       ,     self.num_labels       )

     lowerCAmelCase__          =			self.get_config()

     return config, pixel_values, labels, pixel_labels


    def        a				(	self					:					Optional[int]       )				->	Optional[Any]:
     return MobileViTVaConfig(
         image_size=self.image_size       ,     patch_size=self.patch_size       ,     num_channels=self.num_channels       ,     hidden_act=self.hidden_act       ,     conv_kernel_size=self.conv_kernel_size       ,     output_stride=self.output_stride       ,     classifier_dropout_prob=self.classifier_dropout_prob       ,     initializer_range=self.initializer_range       ,     width_multiplier=self.width_multiplier       ,     ffn_dropout=self.ffn_dropout_prob       ,     attn_dropout=self.attn_dropout_prob       ,     )


    def        a				(	self					:					Dict       ,     SCREAMING_SNAKE_CASE__					:					List[str]       ,     SCREAMING_SNAKE_CASE__					:					Optional[int]       ,     SCREAMING_SNAKE_CASE__					:					List[Any]       ,     SCREAMING_SNAKE_CASE__					:					Tuple       )				->	int:
     lowerCAmelCase__          =			MobileViTVaModel(config=SCREAMING_SNAKE_CASE__       )
     model.to(SCREAMING_SNAKE_CASE__       )
     model.eval()
     lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       )
     self.parent.assertEqual(
         result.last_hidden_state.shape       ,     (
             self.batch_size,
             self.last_hidden_size,
             self.image_size // self.output_stride,
             self.image_size // self.output_stride,
         )       ,     )


    def        a				(	self					:					Dict       ,     SCREAMING_SNAKE_CASE__					:					Dict       ,     SCREAMING_SNAKE_CASE__					:					Optional[Any]       ,     SCREAMING_SNAKE_CASE__					:					str       ,     SCREAMING_SNAKE_CASE__					:					Tuple       )				->	str:
     lowerCAmelCase__          =			self.num_labels
     lowerCAmelCase__          =			MobileViTVaForImageClassification(SCREAMING_SNAKE_CASE__       )
     model.to(SCREAMING_SNAKE_CASE__       )
     model.eval()
     lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       ,     labels=SCREAMING_SNAKE_CASE__       )
     self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.num_labels)       )


    def        a				(	self					:					Optional[int]       ,     SCREAMING_SNAKE_CASE__					:					Union[str, Any]       ,     SCREAMING_SNAKE_CASE__					:					int       ,     SCREAMING_SNAKE_CASE__					:					int       ,     SCREAMING_SNAKE_CASE__					:					List[Any]       )				->	str:
     lowerCAmelCase__          =			self.num_labels
     lowerCAmelCase__          =			MobileViTVaForSemanticSegmentation(SCREAMING_SNAKE_CASE__       )
     model.to(SCREAMING_SNAKE_CASE__       )
     model.eval()
     lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       )
     self.parent.assertEqual(
         result.logits.shape       ,     (
             self.batch_size,
             self.num_labels,
             self.image_size // self.output_stride,
             self.image_size // self.output_stride,
         )       ,     )
     lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       ,     labels=SCREAMING_SNAKE_CASE__       )
     self.parent.assertEqual(
         result.logits.shape       ,     (
             self.batch_size,
             self.num_labels,
             self.image_size // self.output_stride,
             self.image_size // self.output_stride,
         )       ,     )


    def        a				(	self					:					str       )				->	Union[str, Any]:
     lowerCAmelCase__          =			self.prepare_config_and_inputs()
     lowerCAmelCase__     ,		lowerCAmelCase__     ,		lowerCAmelCase__     ,		lowerCAmelCase__          =			config_and_inputs
     lowerCAmelCase__          =			{"pixel_values": pixel_values}
     return config, inputs_dict






@require_torch
class 			__lowerCamelCase	(   UpperCamelCase__     ,    UpperCamelCase__     ,    unittest.TestCase   ):




    """simple docstring"""

    snake_case__ =				(
        (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
        if is_torch_available()
        else ()
    )

    snake_case__ =				(
        {
            "feature-extraction": MobileViTVaModel,
            "image-classification": MobileViTVaForImageClassification,
            "image-segmentation": MobileViTVaForSemanticSegmentation,
        }
        if is_torch_available()
        else {}
    )

    snake_case__ =				False
    snake_case__ =				False
    snake_case__ =				False
    snake_case__ =				False


    def        a				(	self					:					str       )				->	str:
     lowerCAmelCase__          =			MobileViTVaModelTester(self       )
     lowerCAmelCase__          =			MobileViTVaConfigTester(self       ,     config_class=SCREAMING_SNAKE_CASE__       ,     has_text_modality=SCREAMING_SNAKE_CASE__       )


    def        a				(	self					:					Dict       )				->	Any:
     self.config_tester.run_common_tests()


    @unittest.skip(reason="MobileViTV2 does not use inputs_embeds"       )
    def        a				(	self					:					Optional[Any]       )				->	str:
     pass


    @unittest.skip(reason="MobileViTV2 does not support input and output embeddings"       )
    def        a				(	self					:					List[Any]       )				->	List[str]:
     pass


    @unittest.skip(reason="MobileViTV2 does not output attentions"       )
    def        a				(	self					:					str       )				->	Optional[Any]:
     pass


    @require_torch_multi_gpu
    @unittest.skip(reason="Got `CUDA error: misaligned address` for tests after this one being run."       )
    def        a				(	self					:					Any       )				->	str:
     pass


    @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."       )
    def        a				(	self					:					int       )				->	Union[str, Any]:
     pass


    def        a				(	self					:					Dict       )				->	Union[str, Any]:
     lowerCAmelCase__     ,		lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs_for_common()

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

      lowerCAmelCase__          =			["pixel_values"]
      self.assertListEqual(arg_names[:1]       ,     SCREAMING_SNAKE_CASE__       )


    def        a				(	self					:					Tuple       )				->	Optional[Any]:
     lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__       )


    def        a				(	self					:					Union[str, Any]       )				->	Dict:
     def check_hidden_states_output(SCREAMING_SNAKE_CASE__					:					str       ,     SCREAMING_SNAKE_CASE__					:					int       ,     SCREAMING_SNAKE_CASE__					:					Tuple       ):
      lowerCAmelCase__          =			model_class(SCREAMING_SNAKE_CASE__       )
      model.to(SCREAMING_SNAKE_CASE__       )
      model.eval()

      with torch.no_grad():
       lowerCAmelCase__          =			model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__       ,     SCREAMING_SNAKE_CASE__       )       )

      lowerCAmelCase__          =			outputs.hidden_states

      lowerCAmelCase__          =			5
      self.assertEqual(len(SCREAMING_SNAKE_CASE__       )       ,     SCREAMING_SNAKE_CASE__       )

      # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
      # with the width and height being successively divided by 2.
      lowerCAmelCase__          =			2
      for i in range(len(SCREAMING_SNAKE_CASE__       )       ):
       self.assertListEqual(
           list(hidden_states[i].shape[-2:]       )       ,     [self.model_tester.image_size // divisor, self.model_tester.image_size // divisor]       ,     )
       divisor *= 2

      self.assertEqual(self.model_tester.output_stride       ,     divisor // 2       )

     lowerCAmelCase__     ,		lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
      lowerCAmelCase__          =			True
      check_hidden_states_output(SCREAMING_SNAKE_CASE__       ,     SCREAMING_SNAKE_CASE__       ,     SCREAMING_SNAKE_CASE__       )

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

      check_hidden_states_output(SCREAMING_SNAKE_CASE__       ,     SCREAMING_SNAKE_CASE__       ,     SCREAMING_SNAKE_CASE__       )


    def        a				(	self					:					Dict       )				->	Any:
     lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE__       )


    def        a				(	self					:					str       )				->	Dict:
     lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_semantic_segmentation(*SCREAMING_SNAKE_CASE__       )


    @slow
    def        a				(	self					:					int       )				->	Any:
     for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
      lowerCAmelCase__          =			MobileViTVaModel.from_pretrained(SCREAMING_SNAKE_CASE__       )
      self.assertIsNotNone(SCREAMING_SNAKE_CASE__       )






def 							_A       (						):
 """simple docstring"""

 lowerCAmelCase__          =			Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
 return image






@require_torch
@require_vision
class 			__lowerCamelCase	(   unittest.TestCase   ):




    """simple docstring"""

    @cached_property
    def        a				(	self					:					Optional[int]       )				->	Tuple:
     return (
         MobileViTImageProcessor.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256"       )
         if is_vision_available()
         else None
     )


    @slow
    def        a				(	self					:					Any       )				->	Dict:
     lowerCAmelCase__          =			MobileViTVaForImageClassification.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256"       ).to(
         SCREAMING_SNAKE_CASE__       )

     lowerCAmelCase__          =			self.default_image_processor
     lowerCAmelCase__          =			prepare_img()
     lowerCAmelCase__          =			image_processor(images=SCREAMING_SNAKE_CASE__       ,     return_tensors="pt"       ).to(SCREAMING_SNAKE_CASE__       )

     # forward pass
     with torch.no_grad():
      lowerCAmelCase__          =			model(**SCREAMING_SNAKE_CASE__       )

     # verify the logits
     lowerCAmelCase__          =			torch.Size((1, 1_000)       )
     self.assertEqual(outputs.logits.shape       ,     SCREAMING_SNAKE_CASE__       )

     lowerCAmelCase__          =			torch.tensor([-1.6_3_3_6e0_0, -7.3_2_0_4e-0_2, -5.1_8_8_3e-0_1]       ).to(SCREAMING_SNAKE_CASE__       )

     self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,     SCREAMING_SNAKE_CASE__       ,     atol=1e-4       )       )


    @slow
    def        a				(	self					:					List[Any]       )				->	Union[str, Any]:
     lowerCAmelCase__          =			MobileViTVaForSemanticSegmentation.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"       )
     lowerCAmelCase__          =			model.to(SCREAMING_SNAKE_CASE__       )

     lowerCAmelCase__          =			MobileViTImageProcessor.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"       )

     lowerCAmelCase__          =			prepare_img()
     lowerCAmelCase__          =			image_processor(images=SCREAMING_SNAKE_CASE__       ,     return_tensors="pt"       ).to(SCREAMING_SNAKE_CASE__       )

     # forward pass
     with torch.no_grad():
      lowerCAmelCase__          =			model(**SCREAMING_SNAKE_CASE__       )
     lowerCAmelCase__          =			outputs.logits

     # verify the logits
     lowerCAmelCase__          =			torch.Size((1, 21, 32, 32)       )
     self.assertEqual(logits.shape       ,     SCREAMING_SNAKE_CASE__       )

     lowerCAmelCase__          =			torch.tensor(
         [
             [[7.0_863, 7.1_525, 6.8_201], [6.6_931, 6.8_770, 6.8_933], [6.2_978, 7.0_366, 6.9_636]],
             [[-3.7_134, -3.6_712, -3.6_675], [-3.5_825, -3.3_549, -3.4_777], [-3.3_435, -3.3_979, -3.2_857]],
             [[-2.9_329, -2.8_003, -2.7_369], [-3.0_564, -2.4_780, -2.0_207], [-2.6_889, -1.9_298, -1.7_640]],
         ]       ,     device=SCREAMING_SNAKE_CASE__       ,     )

     self.assertTrue(torch.allclose(logits[0, :3, :3, :3]       ,     SCREAMING_SNAKE_CASE__       ,     atol=1e-4       )       )


    @slow
    def        a				(	self					:					Union[str, Any]       )				->	Union[str, Any]:
     lowerCAmelCase__          =			MobileViTVaForSemanticSegmentation.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"       )
     lowerCAmelCase__          =			model.to(SCREAMING_SNAKE_CASE__       )

     lowerCAmelCase__          =			MobileViTImageProcessor.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"       )

     lowerCAmelCase__          =			prepare_img()
     lowerCAmelCase__          =			image_processor(images=SCREAMING_SNAKE_CASE__       ,     return_tensors="pt"       ).to(SCREAMING_SNAKE_CASE__       )

     # forward pass
     with torch.no_grad():
      lowerCAmelCase__          =			model(**SCREAMING_SNAKE_CASE__       )

     lowerCAmelCase__          =			outputs.logits.detach().cpu()

     lowerCAmelCase__          =			image_processor.post_process_semantic_segmentation(outputs=SCREAMING_SNAKE_CASE__       ,     target_sizes=[(50, 60)]       )
     lowerCAmelCase__          =			torch.Size((50, 60)       )
     self.assertEqual(segmentation[0].shape       ,     SCREAMING_SNAKE_CASE__       )

     lowerCAmelCase__          =			image_processor.post_process_semantic_segmentation(outputs=SCREAMING_SNAKE_CASE__       )
     lowerCAmelCase__          =			torch.Size((32, 32)       )
     self.assertEqual(segmentation[0].shape       ,     SCREAMING_SNAKE_CASE__       )






import string



def 							_A       (						lowerCAmelCase_					: str      ):
     """simple docstring"""

     for key in range(len(string.ascii_uppercase      )      ):
          lowerCAmelCase__          =			""
          for symbol in message:
               if symbol in string.ascii_uppercase:
                    lowerCAmelCase__          =			string.ascii_uppercase.find(lowerCAmelCase_      )
                    lowerCAmelCase__          =			num - key
                    if num < 0:
                         lowerCAmelCase__          =			num + len(string.ascii_uppercase      )
                    lowerCAmelCase__          =			translated + string.ascii_uppercase[num]
               else:
                    lowerCAmelCase__          =			translated + symbol
          print(F'Decryption using Key #{key}: {translated}'      )



def 							_A       (						):
     """simple docstring"""

     lowerCAmelCase__          =			input("Encrypted message: "      )
     lowerCAmelCase__          =			message.upper()
     decrypt(lowerCAmelCase_      )


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     main()
