


'''simple docstring'''







import argparse
import os
import re


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_dummies.py
lowerCAmelCase    :     str					=						"""src/diffusers"""

# Matches is_xxx_available()
lowerCAmelCase    :     Optional[Any]					=						re.compile(r"""is\_([a-z_]*)_available\(\)""")
# Matches from xxx import bla
lowerCAmelCase    :     Any					=						re.compile(r"""\s+from\s+\S*\s+import\s+([^\(\s].*)\n""")


lowerCAmelCase    :     Optional[Any]					=						"""
{0} = None
"""

lowerCAmelCase    :     Tuple					=						"""
class {0}(metaclass=DummyObject):
    _backends = {1}

    def __init__(self, *args, **kwargs):
        requires_backends(self, {1})

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, {1})

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, {1})
"""


lowerCAmelCase    :     Optional[Any]					=						"""
def {0}(*args, **kwargs):
    requires_backends({0}, {1})
"""






def 			lowercase				(_A					):







       """simple docstring"""







       _lowerCAmelCase    :							Union[str, Any]   			=       _re_backend.findall(_A					)
       if len(_A					) == 0:
              return None

       return "_and_".join(_A					)






def 			lowercase				():







       """simple docstring"""







       with open(os.path.join(_A   ,						'__init__.py'					)   ,						'r'   ,						encoding='utf-8'   ,						newline='\n'					) as f:
              _lowerCAmelCase    :							Union[str, Any]   			=       f.readlines()

       # Get to the point we do the actual imports for type checking
       _lowerCAmelCase    :							Union[str, Any]   			=       0
       _lowerCAmelCase    :							Union[str, Any]   			=       {}
       # Go through the end of the file
       while line_index < len(_A					):
              # If the line contains is_backend_available, we grab all objects associated with the `else` block
              _lowerCAmelCase    :							Any   			=       find_backend(lines[line_index]					)
              if backend is not None:
                     while not lines[line_index].startswith('else:'					):
                            line_index += 1
                     line_index += 1
                     _lowerCAmelCase    :							List[str]   			=       []
                     # Until we unindent, add backend objects to the list
                     while line_index < len(_A					) and len(lines[line_index]					) > 1:
                            _lowerCAmelCase    :							Union[str, Any]   			=       lines[line_index]
                            _lowerCAmelCase    :							Union[str, Any]   			=       _re_single_line_import.search(_A					)
                            if single_line_import_search is not None:
                                   objects.extend(single_line_import_search.groups()[0].split(', '					)					)
                            elif line.startswith(' ' * 8					):
                                   objects.append(line[8:-2]					)
                            line_index += 1

                     if len(_A					) > 0:
                            _lowerCAmelCase    :							int   			=       objects
              else:
                     line_index += 1

       return backend_specific_objects






def 			lowercase				(_A   ,						_A					):







       """simple docstring"""







       if name.isupper():
              return DUMMY_CONSTANT.format(_A					)
       elif name.islower():
              return DUMMY_FUNCTION.format(_A   ,						_A					)
       else:
              return DUMMY_CLASS.format(_A   ,						_A					)






def 			lowercase				(_A=None					):







       """simple docstring"""







       if backend_specific_objects is None:
              _lowerCAmelCase    :							List[str]   			=       read_init()
       # For special correspondence backend to module name as used in the function requires_modulename
       _lowerCAmelCase    :							List[str]   			=       {}

       for backend, objects in backend_specific_objects.items():
              _lowerCAmelCase    :							Union[str, Any]   			=       '[' + ', '.join(f'"{b}"' for b in backend.split('_and_'					)					) + ']'
              _lowerCAmelCase    :							Dict   			=       '# This file is autogenerated by the command `make fix-copies`, do not edit.\n'
              dummy_file += "from ..utils import DummyObject, requires_backends\n\n"
              dummy_file += "\n".join([create_dummy_object(_A   ,						_A					) for o in objects]					)
              _lowerCAmelCase    :							List[Any]   			=       dummy_file

       return dummy_files






def 			lowercase				(_A=False					):







       """simple docstring"""







       _lowerCAmelCase    :							List[Any]   			=       create_dummy_files()
       # For special correspondence backend to shortcut as used in utils/dummy_xxx_objects.py
       _lowerCAmelCase    :							List[str]   			=       {'torch': 'pt'}

       # Locate actual dummy modules and read their content.
       _lowerCAmelCase    :							Union[str, Any]   			=       os.path.join(_A   ,						'utils'					)
       _lowerCAmelCase    :							Dict   			=       {
           backend: os.path.join(_A   ,						f'dummy_{short_names.get(_A   ,						_A					)}_objects.py'					)
           for backend in dummy_files.keys()
       }

       _lowerCAmelCase    :							Optional[Any]   			=       {}
       for backend, file_path in dummy_file_paths.items():
              if os.path.isfile(_A					):
                     with open(_A   ,						'r'   ,						encoding='utf-8'   ,						newline='\n'					) as f:
                            _lowerCAmelCase    :							List[str]   			=       f.read()
              else:
                     _lowerCAmelCase    :							Any   			=       ''

       for backend in dummy_files.keys():
              if dummy_files[backend] != actual_dummies[backend]:
                     if overwrite:
                            print(
                                f'Updating diffusers.utils.dummy_{short_names.get(_A   ,						_A					)}_objects.py as the main '
                                '__init__ has new objects.'					)
                            with open(dummy_file_paths[backend]   ,						'w'   ,						encoding='utf-8'   ,						newline='\n'					) as f:
                                   f.write(dummy_files[backend]					)
                     else:
                            raise ValueError(
                                'The main __init__ has objects that are not present in '
                                f'diffusers.utils.dummy_{short_names.get(_A   ,						_A					)}_objects.py. Run `make fix-copies` '
                                'to fix this.'					)


if __name__ == "__main__":
       lowerCAmelCase    :     List[str]					=						argparse.ArgumentParser()
       parser.add_argument("""--fix_and_overwrite""", action="""store_true""", help="""Whether to fix inconsistencies.""")
       lowerCAmelCase    :     Dict					=						parser.parse_args()

       check_dummies(args.fix_and_overwrite)





'''simple docstring'''







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



     """simple docstring"""






     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							int   			=       self.config_class(**self.inputs_dict   )
            self.parent.assertTrue(hasattr(snake_case__      ,	'width_multiplier'   )   )
class 	UpperCamelCase__					:



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	snake_case__=13      ,	snake_case__=64      ,	snake_case__=2      ,	snake_case__=3      ,	snake_case__="swish"      ,	snake_case__=3      ,	snake_case__=32      ,	snake_case__=0.1      ,	snake_case__=0.02      ,	snake_case__=True      ,	snake_case__=True      ,	snake_case__=10      ,	snake_case__=None      ,	snake_case__=0.25      ,	snake_case__=0.0      ,	snake_case__=0.0      ,	):

            '''simple docstring'''

            _lowerCAmelCase    :							Tuple   			=       parent
            _lowerCAmelCase    :							Optional[int]   			=       batch_size
            _lowerCAmelCase    :							List[Any]   			=       image_size
            _lowerCAmelCase    :							List[Any]   			=       patch_size
            _lowerCAmelCase    :							List[str]   			=       num_channels
            _lowerCAmelCase    :							Optional[Any]   			=       make_divisible(512 * width_multiplier      ,	divisor=8   )
            _lowerCAmelCase    :							Optional[Any]   			=       hidden_act
            _lowerCAmelCase    :							List[Any]   			=       conv_kernel_size
            _lowerCAmelCase    :							Optional[Any]   			=       output_stride
            _lowerCAmelCase    :							List[Any]   			=       classifier_dropout_prob
            _lowerCAmelCase    :							str   			=       use_labels
            _lowerCAmelCase    :							List[str]   			=       is_training
            _lowerCAmelCase    :							Optional[int]   			=       num_labels
            _lowerCAmelCase    :							List[str]   			=       initializer_range
            _lowerCAmelCase    :							str   			=       scope
            _lowerCAmelCase    :							Any   			=       width_multiplier
            _lowerCAmelCase    :							Union[str, Any]   			=       ffn_dropout
            _lowerCAmelCase    :							Optional[int]   			=       attn_dropout







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Optional[Any]   			=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

            _lowerCAmelCase    :							Optional[Any]   			=       None
            _lowerCAmelCase    :							Dict   			=       None
            if self.use_labels:
                   _lowerCAmelCase    :							Optional[Any]   			=       ids_tensor([self.batch_size]      ,	self.num_labels   )
                   _lowerCAmelCase    :							Optional[Any]   			=       ids_tensor([self.batch_size, self.image_size, self.image_size]      ,	self.num_labels   )

            _lowerCAmelCase    :							Optional[int]   			=       self.get_config()

            return config, pixel_values, labels, pixel_labels







     def a	( self   ):

            '''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 a	( self      ,	snake_case__      ,	snake_case__      ,	snake_case__      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Any   			=       MobileViTVaModel(config=snake_case__   )
            model.to(snake_case__   )
            model.eval()
            _lowerCAmelCase    :							str   			=       model(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      ,	snake_case__      ,	snake_case__      ,	snake_case__      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Optional[int]   			=       self.num_labels
            _lowerCAmelCase    :							List[Any]   			=       MobileViTVaForImageClassification(snake_case__   )
            model.to(snake_case__   )
            model.eval()
            _lowerCAmelCase    :							int   			=       model(snake_case__      ,	labels=snake_case__   )
            self.parent.assertEqual(result.logits.shape      ,	(self.batch_size, self.num_labels)   )







     def a	( self      ,	snake_case__      ,	snake_case__      ,	snake_case__      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[Any]   			=       self.num_labels
            _lowerCAmelCase    :							Optional[int]   			=       MobileViTVaForSemanticSegmentation(snake_case__   )
            model.to(snake_case__   )
            model.eval()
            _lowerCAmelCase    :							Dict   			=       model(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    :							Any   			=       model(snake_case__      ,	labels=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   ):

            '''simple docstring'''

            _lowerCAmelCase    :							int   			=       self.prepare_config_and_inputs()
            _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase    :							Optional[int]   			=       config_and_inputs
            _lowerCAmelCase    :							Tuple   			=       {'pixel_values': pixel_values}
            return config, inputs_dict
@require_torch
class 	UpperCamelCase__					( SCREAMING_SNAKE_CASE_    ,					SCREAMING_SNAKE_CASE_    ,					unittest.TestCase	):



     """simple docstring"""






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

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

     __magic_name__    			=    False
     __magic_name__    			=    False
     __magic_name__    			=    False
     __magic_name__    			=    False







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							int   			=       MobileViTVaModelTester(self   )
            _lowerCAmelCase    :							Dict   			=       MobileViTVaConfigTester(self      ,	config_class=snake_case__      ,	has_text_modality=snake_case__   )







     def a	( self   ):

            '''simple docstring'''

            self.config_tester.run_common_tests()







     @unittest.skip(reason='MobileViTV2 does not use inputs_embeds'   )
     def a	( self   ):

            '''simple docstring'''

            pass







     @unittest.skip(reason='MobileViTV2 does not support input and output embeddings'   )
     def a	( self   ):

            '''simple docstring'''

            pass







     @unittest.skip(reason='MobileViTV2 does not output attentions'   )
     def a	( self   ):

            '''simple docstring'''

            pass







     @require_torch_multi_gpu
     @unittest.skip(reason='Got `CUDA error: misaligned address` for tests after this one being run.'   )
     def a	( self   ):

            '''simple docstring'''

            pass







     @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'   )
     def a	( self   ):

            '''simple docstring'''

            pass







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase			,     _lowerCAmelCase    :							Optional[int]   			=       self.model_tester.prepare_config_and_inputs_for_common()

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

                   _lowerCAmelCase    :							Any   			=       ['pixel_values']
                   self.assertListEqual(arg_names[:1]      ,	snake_case__   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Optional[int]   			=       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*snake_case__   )







     def a	( self   ):

            '''simple docstring'''

            def check_hidden_states_output(snake_case__      ,	snake_case__      ,	snake_case__   ):
                   _lowerCAmelCase    :							Dict   			=       model_class(snake_case__   )
                   model.to(snake_case__   )
                   model.eval()

                   with torch.no_grad():
                          _lowerCAmelCase    :							Optional[Any]   			=       model(**self._prepare_for_class(snake_case__      ,	snake_case__   )   )

                   _lowerCAmelCase    :							List[str]   			=       outputs.hidden_states

                   _lowerCAmelCase    :							List[str]   			=       5
                   self.assertEqual(len(snake_case__   )      ,	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    :							List[Any]   			=       2
                   for i in range(len(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    :							Optional[int]   			=       self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                   _lowerCAmelCase    :							Optional[int]   			=       True
                   check_hidden_states_output(snake_case__      ,	snake_case__      ,	snake_case__   )

                   # check that output_hidden_states also work using config
                   del inputs_dict["output_hidden_states"]
                   _lowerCAmelCase    :							Any   			=       True

                   check_hidden_states_output(snake_case__      ,	snake_case__      ,	snake_case__   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Dict   			=       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*snake_case__   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Any   			=       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_semantic_segmentation(*snake_case__   )







     @slow
     def a	( self   ):

            '''simple docstring'''

            for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   _lowerCAmelCase    :							Dict   			=       MobileViTVaModel.from_pretrained(snake_case__   )
                   self.assertIsNotNone(snake_case__   )






def 			lowercase				():







       """simple docstring"""







       _lowerCAmelCase    :							Any   			=       Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'					)
       return image
@require_torch
@require_vision
class 	UpperCamelCase__					( unittest.TestCase	):



     """simple docstring"""






     @cached_property
     def a	( self   ):

            '''simple docstring'''

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







     @slow
     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Union[str, Any]   			=       MobileViTVaForImageClassification.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256'   ).to(
                snake_case__   )

            _lowerCAmelCase    :							str   			=       self.default_image_processor
            _lowerCAmelCase    :							Any   			=       prepare_img()
            _lowerCAmelCase    :							Optional[int]   			=       image_processor(images=snake_case__      ,	return_tensors='pt'   ).to(snake_case__   )

            # forward pass
            with torch.no_grad():
                   _lowerCAmelCase    :							Tuple   			=       model(**snake_case__   )

            # verify the logits
            _lowerCAmelCase    :							Optional[Any]   			=       torch.Size((1, 1000)   )
            self.assertEqual(outputs.logits.shape      ,	snake_case__   )

            _lowerCAmelCase    :							Tuple   			=       torch.tensor([-1.6336E00, -7.3204E-02, -5.1883E-01]   ).to(snake_case__   )

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







     @slow
     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[str]   			=       MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3'   )
            _lowerCAmelCase    :							Any   			=       model.to(snake_case__   )

            _lowerCAmelCase    :							int   			=       MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3'   )

            _lowerCAmelCase    :							Optional[int]   			=       prepare_img()
            _lowerCAmelCase    :							Dict   			=       image_processor(images=snake_case__      ,	return_tensors='pt'   ).to(snake_case__   )

            # forward pass
            with torch.no_grad():
                   _lowerCAmelCase    :							int   			=       model(**snake_case__   )
            _lowerCAmelCase    :							Dict   			=       outputs.logits

            # verify the logits
            _lowerCAmelCase    :							str   			=       torch.Size((1, 21, 32, 32)   )
            self.assertEqual(logits.shape      ,	snake_case__   )

            _lowerCAmelCase    :							Any   			=       torch.tensor(
                [
                    [[7.0863, 7.1525, 6.8201], [6.6931, 6.8770, 6.8933], [6.2978, 7.0366, 6.9636]],
                    [[-3.7134, -3.6712, -3.6675], [-3.5825, -3.3549, -3.4777], [-3.3435, -3.3979, -3.2857]],
                    [[-2.9329, -2.8003, -2.7369], [-3.0564, -2.4780, -2.0207], [-2.6889, -1.9298, -1.7640]],
                ]      ,	device=snake_case__      ,	)

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







     @slow
     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Any   			=       MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3'   )
            _lowerCAmelCase    :							List[Any]   			=       model.to(snake_case__   )

            _lowerCAmelCase    :							str   			=       MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3'   )

            _lowerCAmelCase    :							Tuple   			=       prepare_img()
            _lowerCAmelCase    :							List[str]   			=       image_processor(images=snake_case__      ,	return_tensors='pt'   ).to(snake_case__   )

            # forward pass
            with torch.no_grad():
                   _lowerCAmelCase    :							Any   			=       model(**snake_case__   )

            _lowerCAmelCase    :							Optional[Any]   			=       outputs.logits.detach().cpu()

            _lowerCAmelCase    :							Any   			=       image_processor.post_process_semantic_segmentation(outputs=snake_case__      ,	target_sizes=[(50, 60)]   )
            _lowerCAmelCase    :							List[Any]   			=       torch.Size((50, 60)   )
            self.assertEqual(segmentation[0].shape      ,	snake_case__   )

            _lowerCAmelCase    :							List[str]   			=       image_processor.post_process_semantic_segmentation(outputs=snake_case__   )
            _lowerCAmelCase    :							Tuple   			=       torch.Size((32, 32)   )
            self.assertEqual(segmentation[0].shape      ,	snake_case__   )

