




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       a__	( UpperCamelCase__				):







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



          '''simple docstring'''



          a     =				self.config_class(**self.inputs_dict			)
          self.parent.assertTrue(hasattr(A  ,		"width_multiplier"			)			)







class       a__	:







     def __init__(     self  ,		A  ,		A=13  ,		A=64  ,		A=2  ,		A=3  ,		A="swish"  ,		A=3  ,		A=32  ,		A=0.1  ,		A=0.0_2  ,		A=True  ,		A=True  ,		A=10  ,		A=None  ,		A=0.2_5  ,		A=0.0  ,		A=0.0  ,		)  ->   str:



          '''simple docstring'''



          a     =				parent
          a     =				batch_size
          a     =				image_size
          a     =				patch_size
          a     =				num_channels
          a     =				make_divisible(512 * width_multiplier  ,		divisor=8			)
          a     =				hidden_act
          a     =				conv_kernel_size
          a     =				output_stride
          a     =				classifier_dropout_prob
          a     =				use_labels
          a     =				is_training
          a     =				num_labels
          a     =				initializer_range
          a     =				scope
          a     =				width_multiplier
          a     =				ffn_dropout
          a     =				attn_dropout







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



          '''simple docstring'''



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

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

          a     =				self.get_config()

          return config, pixel_values, labels, pixel_labels







     def       lowerCAmelCase_    (     self			)  ->   Any:



          '''simple docstring'''



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



          '''simple docstring'''



          a     =				MobileViTVaModel(config=A			)
          model.to(A			)
          model.eval()
          a     =				model(A			)
          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       lowerCAmelCase_    (     self  ,		A  ,		A  ,		A  ,		A			)  ->   Tuple:



          '''simple docstring'''



          a     =				self.num_labels
          a     =				MobileViTVaForImageClassification(A			)
          model.to(A			)
          model.eval()
          a     =				model(A  ,		labels=A			)
          self.parent.assertEqual(result.logits.shape  ,		(self.batch_size, self.num_labels)			)







     def       lowerCAmelCase_    (     self  ,		A  ,		A  ,		A  ,		A			)  ->   Any:



          '''simple docstring'''



          a     =				self.num_labels
          a     =				MobileViTVaForSemanticSegmentation(A			)
          model.to(A			)
          model.eval()
          a     =				model(A			)
          self.parent.assertEqual(
              result.logits.shape  ,		(
                  self.batch_size,
                  self.num_labels,
                  self.image_size // self.output_stride,
                  self.image_size // self.output_stride,
              )  ,		)
          a     =				model(A  ,		labels=A			)
          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       lowerCAmelCase_    (     self			)  ->   Optional[int]:



          '''simple docstring'''



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







@require_torch
class       a__	( UpperCamelCase__       , UpperCamelCase__       , unittest.TestCase				):
     a		:      Tuple		 =     (
         (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
         if is_torch_available()
         else ()
     )

     a		:      List[str]		 =     (
         {
             """feature-extraction""": MobileViTVaModel,
             """image-classification""": MobileViTVaForImageClassification,
             """image-segmentation""": MobileViTVaForSemanticSegmentation,
         }
         if is_torch_available()
         else {}
     )

     a		:      Union[str, Any]		 =     False
     a		:      Dict		 =     False
     a		:      List[str]		 =     False
     a		:      List[Any]		 =     False







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



          '''simple docstring'''



          a     =				MobileViTVaModelTester(self			)
          a     =				MobileViTVaConfigTester(self  ,		config_class=A  ,		has_text_modality=A			)







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



          '''simple docstring'''



          self.config_tester.run_common_tests()







     @unittest.skip(reason="MobileViTV2 does not use inputs_embeds"			)
     def       lowerCAmelCase_    (     self			)  ->   Dict:



          '''simple docstring'''



          pass







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



          '''simple docstring'''



          pass







     @unittest.skip(reason="MobileViTV2 does not output attentions"			)
     def       lowerCAmelCase_    (     self			)  ->   Optional[int]:



          '''simple docstring'''



          pass







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



          '''simple docstring'''



          pass







     @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."			)
     def       lowerCAmelCase_    (     self			)  ->   Optional[int]:



          '''simple docstring'''



          pass







     def       lowerCAmelCase_    (     self			)  ->   Tuple:



          '''simple docstring'''



          a  ,				a     =				self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               a     =				model_class(A			)
               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]  ,		A			)







     def       lowerCAmelCase_    (     self			)  ->   int:



          '''simple docstring'''



          a     =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*A			)







     def       lowerCAmelCase_    (     self			)  ->   Tuple:



          '''simple docstring'''



          def check_hidden_states_output(A  ,		A  ,		A			):
               a     =				model_class(A			)
               model.to(A			)
               model.eval()

               with torch.no_grad():
                    a     =				model(**self._prepare_for_class(A  ,		A			)			)

               a     =				outputs.hidden_states

               a     =				5
               self.assertEqual(len(A			)  ,		A			)

               # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
               # with the width and height being successively divided by 2.
               a     =				2
               for i in range(len(A			)			):
                    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			)

          a  ,				a     =				self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               a     =				True
               check_hidden_states_output(A  ,		A  ,		A			)

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

               check_hidden_states_output(A  ,		A  ,		A			)







     def       lowerCAmelCase_    (     self			)  ->   int:



          '''simple docstring'''



          a     =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*A			)







     def       lowerCAmelCase_    (     self			)  ->   int:



          '''simple docstring'''



          a     =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_semantic_segmentation(*A			)







     @slow
     def       lowerCAmelCase_    (     self			)  ->   Tuple:



          '''simple docstring'''



          for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               a     =				MobileViTVaModel.from_pretrained(A			)
               self.assertIsNotNone(A			)







def  SCREAMING_SNAKE_CASE							(       )      ->					str:
     a     =				Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
     return image





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







     @cached_property
     def       lowerCAmelCase_    (     self			)  ->   Optional[int]:



          '''simple docstring'''



          return (
              MobileViTImageProcessor.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256"			)
              if is_vision_available()
              else None
          )







     @slow
     def       lowerCAmelCase_    (     self			)  ->   List[Any]:



          '''simple docstring'''



          a     =				MobileViTVaForImageClassification.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256"			).to(
              A			)

          a     =				self.default_image_processor
          a     =				prepare_img()
          a     =				image_processor(images=A  ,		return_tensors="pt"			).to(A			)

          # forward pass
          with torch.no_grad():
               a     =				model(**A			)

          # verify the logits
          a     =				torch.Size((1, 1000)			)
          self.assertEqual(outputs.logits.shape  ,		A			)

          a     =				torch.tensor([-1.6_336e00, -7.3_204e-02, -5.1_883e-01]			).to(A			)

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







     @slow
     def       lowerCAmelCase_    (     self			)  ->   Union[str, Any]:



          '''simple docstring'''



          a     =				MobileViTVaForSemanticSegmentation.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"			)
          a     =				model.to(A			)

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

          a     =				prepare_img()
          a     =				image_processor(images=A  ,		return_tensors="pt"			).to(A			)

          # forward pass
          with torch.no_grad():
               a     =				model(**A			)
          a     =				outputs.logits

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

          a     =				torch.tensor(
              [
                  [[7.0_8_6_3, 7.1_5_2_5, 6.8_2_0_1], [6.6_9_3_1, 6.8_7_7_0, 6.8_9_3_3], [6.2_9_7_8, 7.0_3_6_6, 6.9_6_3_6]],
                  [[-3.7_1_3_4, -3.6_7_1_2, -3.6_6_7_5], [-3.5_8_2_5, -3.3_5_4_9, -3.4_7_7_7], [-3.3_4_3_5, -3.3_9_7_9, -3.2_8_5_7]],
                  [[-2.9_3_2_9, -2.8_0_0_3, -2.7_3_6_9], [-3.0_5_6_4, -2.4_7_8_0, -2.0_2_0_7], [-2.6_8_8_9, -1.9_2_9_8, -1.7_6_4_0]],
              ]  ,		device=A  ,		)

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







     @slow
     def       lowerCAmelCase_    (     self			)  ->   Union[str, Any]:



          '''simple docstring'''



          a     =				MobileViTVaForSemanticSegmentation.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"			)
          a     =				model.to(A			)

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

          a     =				prepare_img()
          a     =				image_processor(images=A  ,		return_tensors="pt"			).to(A			)

          # forward pass
          with torch.no_grad():
               a     =				model(**A			)

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

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

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







import os
import tempfile
import unittest

from transformers.models.marian.convert_marian_tatoeba_to_pytorch import DEFAULT_REPO, TatoebaConverter
from transformers.testing_utils import slow
from transformers.utils import cached_property




@unittest.skipUnless(os.path.exists(UpperCamelCase__				)       , """Tatoeba directory does not exist."""				)
class       a__	( unittest.TestCase				):







     @cached_property
     def       lowerCAmelCase_    (     self			)  ->   List[str]:



          '''simple docstring'''



          a     =				tempfile.mkdtemp()
          return TatoebaConverter(save_dir=A			)







     @slow
     def       lowerCAmelCase_    (     self			)  ->   int:



          '''simple docstring'''



          self.resolver.convert_models(["heb-eng"]			)







     @slow
     def       lowerCAmelCase_    (     self			)  ->   Dict:



          '''simple docstring'''



          a  ,				a     =				self.resolver.write_model_card("opus-mt-he-en"  ,		dry_run=A			)
          assert mmeta["long_pair"] == "heb-eng"

