


import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY







@is_pipeline_test
class  snake_case_     (unittest.TestCase   ):
					UpperCAmelCase__      :					str					   =    MODEL_FOR_MASKED_LM_MAPPING
					UpperCAmelCase__      :					Union[str, Any]					   =    TF_MODEL_FOR_MASKED_LM_MAPPING
					def 				lowerCamelCase__(   self     :List[str]   )      ->					str:
												super().tearDown()
												# clean-up as much as possible GPU memory occupied by PyTorch
												gc.collect()
												if is_torch_available():
																			import torch

																			torch.cuda.empty_cache()
					@require_tf
					def 				lowerCamelCase__(   self     :List[str]   )      ->					str:
												a__    =  pipeline(task='fill-mask'    ,model='sshleifer/tiny-distilroberta-base'    ,top_k=2    ,framework='tf'   )
												a__    =  unmasker('My name is <mask>'   )
												self.assertEqual(
												    nested_simplify(__snake_case    ,decimals=6   )    ,[
												        {'sequence': 'My name is grouped', 'score': 2.1E-05, 'token': 3_80_15, 'token_str': ' grouped'},
												        {'sequence': 'My name is accuser', 'score': 2.1E-05, 'token': 2_55_06, 'token_str': ' accuser'},
												    ]    ,)

												a__    =  unmasker('The largest city in France is <mask>'   )
												self.assertEqual(
												    nested_simplify(__snake_case    ,decimals=6   )    ,[
												        {
												            'sequence': 'The largest city in France is grouped',
												            'score': 2.1E-05,
												            'token': 3_80_15,
												            'token_str': ' grouped',
												        },
												        {
												            'sequence': 'The largest city in France is accuser',
												            'score': 2.1E-05,
												            'token': 2_55_06,
												            'token_str': ' accuser',
												        },
												    ]    ,)

												a__    =  unmasker('My name is <mask>'    ,targets=[' Patrick', ' Clara', ' Teven']    ,top_k=3   )
												self.assertEqual(
												    nested_simplify(__snake_case    ,decimals=6   )    ,[
												        {'sequence': 'My name is Clara', 'score': 2E-05, 'token': 1_36_06, 'token_str': ' Clara'},
												        {'sequence': 'My name is Patrick', 'score': 2E-05, 'token': 34_99, 'token_str': ' Patrick'},
												        {'sequence': 'My name is Te', 'score': 1.9E-05, 'token': 29_41, 'token_str': ' Te'},
												    ]    ,)
					@require_torch
					def 				lowerCamelCase__(   self     :List[Any]   )      ->					Optional[int]:
												a__    =  pipeline(task='fill-mask'    ,model='sshleifer/tiny-distilroberta-base'    ,top_k=2    ,framework='pt'   )

												a__    =  unmasker('My name is <mask>'   )
												self.assertEqual(
												    nested_simplify(__snake_case    ,decimals=6   )    ,[
												        {'sequence': 'My name is Maul', 'score': 2.2E-05, 'token': 3_56_76, 'token_str': ' Maul'},
												        {'sequence': 'My name isELS', 'score': 2.2E-05, 'token': 1_64_16, 'token_str': 'ELS'},
												    ]    ,)

												a__    =  unmasker('The largest city in France is <mask>'   )
												self.assertEqual(
												    nested_simplify(__snake_case    ,decimals=6   )    ,[
												        {
												            'sequence': 'The largest city in France is Maul',
												            'score': 2.2E-05,
												            'token': 3_56_76,
												            'token_str': ' Maul',
												        },
												        {'sequence': 'The largest city in France isELS', 'score': 2.2E-05, 'token': 1_64_16, 'token_str': 'ELS'},
												    ]    ,)

												a__    =  unmasker('My name is <mask>'    ,targets=[' Patrick', ' Clara', ' Teven']    ,top_k=3   )
												self.assertEqual(
												    nested_simplify(__snake_case    ,decimals=6   )    ,[
												        {'sequence': 'My name is Patrick', 'score': 2.1E-05, 'token': 34_99, 'token_str': ' Patrick'},
												        {'sequence': 'My name is Te', 'score': 2E-05, 'token': 29_41, 'token_str': ' Te'},
												        {'sequence': 'My name is Clara', 'score': 2E-05, 'token': 1_36_06, 'token_str': ' Clara'},
												    ]    ,)

												a__    =  unmasker('My name is <mask> <mask>'    ,top_k=2   )

												self.assertEqual(
												    nested_simplify(__snake_case    ,decimals=6   )    ,[
												        [
												            {
												                'score': 2.2E-05,
												                'token': 3_56_76,
												                'token_str': ' Maul',
												                'sequence': '<s>My name is Maul<mask></s>',
												            },
												            {'score': 2.2E-05, 'token': 1_64_16, 'token_str': 'ELS', 'sequence': '<s>My name isELS<mask></s>'},
												        ],
												        [
												            {
												                'score': 2.2E-05,
												                'token': 3_56_76,
												                'token_str': ' Maul',
												                'sequence': '<s>My name is<mask> Maul</s>',
												            },
												            {'score': 2.2E-05, 'token': 1_64_16, 'token_str': 'ELS', 'sequence': '<s>My name is<mask>ELS</s>'},
												        ],
												    ]    ,)
					@require_torch_gpu
					def 				lowerCamelCase__(   self     :Any   )      ->					Optional[int]:
												a__    =  pipeline('fill-mask'    ,model='hf-internal-testing/tiny-random-distilbert'    ,device=0    ,framework='pt'   )

												# convert model to fp16
												pipe.model.half()

												a__    =  pipe('Paris is the [MASK] of France.'   )
												# We actually don't care about the result, we just want to make sure
												# it works, meaning the float16 tensor got casted back to float32
												# for postprocessing.
												self.assertIsInstance(__snake_case    ,__snake_case   )
					@slow
					@require_torch
					def 				lowerCamelCase__(   self     :List[Any]   )      ->					int:
												a__    =  pipeline(task='fill-mask'    ,model='distilroberta-base'    ,top_k=2    ,framework='pt'   )
												self.run_large_test(__snake_case   )
					@slow
					@require_tf
					def 				lowerCamelCase__(   self     :Dict   )      ->					str:
												a__    =  pipeline(task='fill-mask'    ,model='distilroberta-base'    ,top_k=2    ,framework='tf'   )
												self.run_large_test(__snake_case   )
					def 				lowerCamelCase__(   self     :int    ,__snake_case     :Optional[int]   )      ->					Union[str, Any]:
												a__    =  unmasker('My name is <mask>'   )
												self.assertEqual(
												    nested_simplify(__snake_case   )    ,[
												        {'sequence': 'My name is John', 'score': 0.0_08, 'token': 6_10, 'token_str': ' John'},
												        {'sequence': 'My name is Chris', 'score': 0.0_07, 'token': 15_73, 'token_str': ' Chris'},
												    ]    ,)
												a__    =  unmasker('The largest city in France is <mask>'   )
												self.assertEqual(
												    nested_simplify(__snake_case   )    ,[
												        {
												            'sequence': 'The largest city in France is Paris',
												            'score': 0.2_51,
												            'token': 22_01,
												            'token_str': ' Paris',
												        },
												        {
												            'sequence': 'The largest city in France is Lyon',
												            'score': 0.2_14,
												            'token': 1_27_90,
												            'token_str': ' Lyon',
												        },
												    ]    ,)

												a__    =  unmasker('My name is <mask>'    ,targets=[' Patrick', ' Clara', ' Teven']    ,top_k=3   )
												self.assertEqual(
												    nested_simplify(__snake_case   )    ,[
												        {'sequence': 'My name is Patrick', 'score': 0.0_05, 'token': 34_99, 'token_str': ' Patrick'},
												        {'sequence': 'My name is Clara', 'score': 0.0_00, 'token': 1_36_06, 'token_str': ' Clara'},
												        {'sequence': 'My name is Te', 'score': 0.0_00, 'token': 29_41, 'token_str': ' Te'},
												    ]    ,)
					@require_torch
					def 				lowerCamelCase__(   self     :List[str]   )      ->					int:
												a__    =  pipeline(task='fill-mask'    ,model='sshleifer/tiny-distilroberta-base'    ,framework='pt'   )
												a__    =  None
												a__    =  None
												self.run_pipeline_test(__snake_case    ,[]   )
					@require_tf
					def 				lowerCamelCase__(   self     :Tuple   )      ->					Optional[int]:
												a__    =  pipeline(task='fill-mask'    ,model='sshleifer/tiny-distilroberta-base'    ,framework='tf'   )
												a__    =  None
												a__    =  None
												self.run_pipeline_test(__snake_case    ,[]   )
					def 				lowerCamelCase__(   self     :List[str]    ,__snake_case     :Union[str, Any]    ,__snake_case     :Optional[Any]    ,__snake_case     :int   )      ->					Any:
												if tokenizer is None or tokenizer.mask_token_id is None:
																			self.skipTest('The provided tokenizer has no mask token, (probably reformer or wav2vec2)'   )

												a__    =  FillMaskPipeline(model=__snake_case    ,tokenizer=__snake_case   )
												a__    =  [
												    F'This is another {tokenizer.mask_token} test',
												]
												return fill_masker, examples
					def 				lowerCamelCase__(   self     :Dict    ,__snake_case     :Tuple    ,__snake_case     :List[Any]   )      ->					Any:
												a__    =  fill_masker.tokenizer
												a__    =  fill_masker.model

												a__    =  fill_masker(
												    F'This is a {tokenizer.mask_token}'    ,)
												self.assertEqual(
												    __snake_case    ,[
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												    ]    ,)

												a__    =  fill_masker([F'This is a {tokenizer.mask_token}']   )
												self.assertEqual(
												    __snake_case    ,[
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												    ]    ,)

												a__    =  fill_masker([F'This is a {tokenizer.mask_token}', F'Another {tokenizer.mask_token} great test.']   )
												self.assertEqual(
												    __snake_case    ,[
												        [
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        ],
												        [
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        ],
												    ]    ,)

												with self.assertRaises(__snake_case   ):
																			fill_masker([None]   )
												# No mask_token is not supported
												with self.assertRaises(__snake_case   ):
																			fill_masker('This is'   )

												self.run_test_top_k(__snake_case    ,__snake_case   )
												self.run_test_targets(__snake_case    ,__snake_case   )
												self.run_test_top_k_targets(__snake_case    ,__snake_case   )
												self.fill_mask_with_duplicate_targets_and_top_k(__snake_case    ,__snake_case   )
												self.fill_mask_with_multiple_masks(__snake_case    ,__snake_case   )
					def 				lowerCamelCase__(   self     :Optional[Any]    ,__snake_case     :str    ,__snake_case     :Optional[int]   )      ->					str:
												a__    =  tokenizer.get_vocab()
												a__    =  sorted(vocab.keys()   )[:2]
												# Pipeline argument
												a__    =  FillMaskPipeline(model=__snake_case    ,tokenizer=__snake_case    ,targets=__snake_case   )
												a__    =  fill_masker(F'This is a {tokenizer.mask_token}'   )
												self.assertEqual(
												    __snake_case    ,[
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												    ]    ,)
												a__    =  {vocab[el] for el in targets}
												self.assertEqual({el['token'] for el in outputs}    ,__snake_case   )
												a__    =  [tokenizer.decode([x]   ) for x in target_ids]
												self.assertEqual({el['token_str'] for el in outputs}    ,set(__snake_case   )   )

												# Call argument
												a__    =  FillMaskPipeline(model=__snake_case    ,tokenizer=__snake_case   )
												a__    =  fill_masker(F'This is a {tokenizer.mask_token}'    ,targets=__snake_case   )
												self.assertEqual(
												    __snake_case    ,[
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												    ]    ,)
												a__    =  {vocab[el] for el in targets}
												self.assertEqual({el['token'] for el in outputs}    ,__snake_case   )
												a__    =  [tokenizer.decode([x]   ) for x in target_ids]
												self.assertEqual({el['token_str'] for el in outputs}    ,set(__snake_case   )   )

												# Score equivalence
												a__    =  fill_masker(F'This is a {tokenizer.mask_token}'    ,targets=__snake_case   )
												a__    =  [top_mask['token_str'] for top_mask in outputs]
												a__    =  [top_mask['score'] for top_mask in outputs]

												# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
												if set(__snake_case   ) == set(__snake_case   ):
																			a__    =  fill_masker(F'This is a {tokenizer.mask_token}'    ,targets=__snake_case   )
																			a__    =  [top_mask['score'] for top_mask in unmasked_targets]
																			self.assertEqual(nested_simplify(__snake_case   )    ,nested_simplify(__snake_case   )   )

												# Raises with invalid
												with self.assertRaises(__snake_case   ):
																			a__    =  fill_masker(F'This is a {tokenizer.mask_token}'    ,targets=[]   )
												# For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
												if "" not in tokenizer.get_vocab():
																			with self.assertRaises(__snake_case   ):
																										a__    =  fill_masker(F'This is a {tokenizer.mask_token}'    ,targets=['']   )
																			with self.assertRaises(__snake_case   ):
																										a__    =  fill_masker(F'This is a {tokenizer.mask_token}'    ,targets=''   )
					def 				lowerCamelCase__(   self     :List[Any]    ,__snake_case     :Dict    ,__snake_case     :Optional[int]   )      ->					List[Any]:
												a__    =  FillMaskPipeline(model=__snake_case    ,tokenizer=__snake_case    ,top_k=2   )
												a__    =  fill_masker(F'This is a {tokenizer.mask_token}'   )
												self.assertEqual(
												    __snake_case    ,[
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												    ]    ,)

												a__    =  FillMaskPipeline(model=__snake_case    ,tokenizer=__snake_case   )
												a__    =  fill_masker(F'This is a {tokenizer.mask_token}'    ,top_k=2   )
												self.assertEqual(
												    __snake_case    ,[
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												    ]    ,)
												self.assertEqual(nested_simplify(__snake_case   )    ,nested_simplify(__snake_case   )   )
					def 				lowerCamelCase__(   self     :Optional[Any]    ,__snake_case     :Tuple    ,__snake_case     :str   )      ->					Tuple:
												a__    =  tokenizer.get_vocab()
												a__    =  FillMaskPipeline(model=__snake_case    ,tokenizer=__snake_case   )

												# top_k=2, ntargets=3
												a__    =  sorted(vocab.keys()   )[:3]
												a__    =  fill_masker(F'This is a {tokenizer.mask_token}'    ,top_k=2    ,targets=__snake_case   )

												# If we use the most probably targets, and filter differently, we should still
												# have the same results
												a__    =  [el['token_str'] for el in sorted(__snake_case    ,key=lambda __snake_case   : x["score"]    ,reverse=__snake_case   )]
												# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
												if set(__snake_case   ).issubset(__snake_case   ):
																			a__    =  fill_masker(F'This is a {tokenizer.mask_token}'    ,top_k=3    ,targets=__snake_case   )
																			# They should yield exactly the same result
																			self.assertEqual(nested_simplify(__snake_case   )    ,nested_simplify(__snake_case   )   )
					def 				lowerCamelCase__(   self     :List[str]    ,__snake_case     :int    ,__snake_case     :int   )      ->					Tuple:
												a__    =  FillMaskPipeline(model=__snake_case    ,tokenizer=__snake_case   )
												a__    =  tokenizer.get_vocab()
												# String duplicates + id duplicates
												a__    =  sorted(vocab.keys()   )[:3]
												a__    =  [targets[0], targets[1], targets[0], targets[2], targets[1]]
												a__    =  fill_masker(F'My name is {tokenizer.mask_token}'    ,targets=__snake_case    ,top_k=10   )

												# The target list contains duplicates, so we can't output more
												# than them
												self.assertEqual(len(__snake_case   )    ,3   )



					def 				lowerCamelCase__(   self     :Tuple    ,__snake_case     :Optional[int]    ,__snake_case     :Optional[int]   )      ->					Union[str, Any]:
												a__    =  FillMaskPipeline(model=__snake_case    ,tokenizer=__snake_case   )

												a__    =  fill_masker(
												    F'This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}'    ,top_k=2   )
												self.assertEqual(
												    __snake_case    ,[
												        [
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        ],
												        [
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        ],
												        [
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												            {'sequence': ANY(__snake_case   ), 'score': ANY(__snake_case   ), 'token': ANY(__snake_case   ), 'token_str': ANY(__snake_case   )},
												        ],
												    ]    ,)








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


snake_case							: Any      =   {
    '''configuration_mobilevit''': ['''MOBILEVIT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''MobileViTConfig''', '''MobileViTOnnxConfig'''],
}

try:
						if not is_vision_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						snake_case							: Union[str, Any]      =   ['''MobileViTFeatureExtractor''']
						snake_case							: int      =   ['''MobileViTImageProcessor''']

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						snake_case							: Dict      =   [
						    '''MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''MobileViTForImageClassification''',
						    '''MobileViTForSemanticSegmentation''',
						    '''MobileViTModel''',
						    '''MobileViTPreTrainedModel''',
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						snake_case							: Tuple      =   [
						    '''TF_MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''TFMobileViTForImageClassification''',
						    '''TFMobileViTForSemanticSegmentation''',
						    '''TFMobileViTModel''',
						    '''TFMobileViTPreTrainedModel''',
						]

if TYPE_CHECKING:
						from .configuration_mobilevit import MOBILEVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, MobileViTConfig, MobileViTOnnxConfig

						try:
												if not is_vision_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .feature_extraction_mobilevit import MobileViTFeatureExtractor
												from .image_processing_mobilevit import MobileViTImageProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_mobilevit import (
												    MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    MobileViTForImageClassification,
												    MobileViTForSemanticSegmentation,
												    MobileViTModel,
												    MobileViTPreTrainedModel,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_mobilevit import (
												    TF_MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFMobileViTForImageClassification,
												    TFMobileViTForSemanticSegmentation,
												    TFMobileViTModel,
												    TFMobileViTPreTrainedModel,
												)


else:
						import sys

						snake_case							: Optional[int]      =   _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




