import gc
import os
import tempfile
import unittest

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
from diffusers.models.attention_processor import (
    Attention,
    AttnProcessor,
    AttnProcessor2_0,
    LoRAAttnProcessor,
    LoRAAttnProcessor2_0,
    LoRAXFormersAttnProcessor,
    XFormersAttnProcessor,
)
from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device



def       __SCREAMING_SNAKE_CASE    (   __UpperCamelCase       :			nn.Module      )				->   Optional[Any]:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__     				= {}
  for name in unet.attn_processors.keys():
    SCREAMING_SNAKE_CASE__     				= None if name.endswith("""attn1.processor"""      ) else unet.config.cross_attention_dim
    if name.startswith("""mid_block"""      ):
      SCREAMING_SNAKE_CASE__     				= unet.config.block_out_channels[-1]
    elif name.startswith("""up_blocks"""      ):
      SCREAMING_SNAKE_CASE__     				= int(name[len("""up_blocks."""      )]      )
      SCREAMING_SNAKE_CASE__     				= list(reversed(unet.config.block_out_channels      )      )[block_id]
    elif name.startswith("""down_blocks"""      ):
      SCREAMING_SNAKE_CASE__     				= int(name[len("""down_blocks."""      )]      )
      SCREAMING_SNAKE_CASE__     				= unet.config.block_out_channels[block_id]
    SCREAMING_SNAKE_CASE__     				= (
        LoRAAttnProcessor2_0 if hasattr(__UpperCamelCase					,	"""scaled_dot_product_attention"""      ) else LoRAAttnProcessor
    )
    SCREAMING_SNAKE_CASE__     				= lora_attn_processor_class(
        hidden_size=__UpperCamelCase					,	cross_attention_dim=__UpperCamelCase      )
  SCREAMING_SNAKE_CASE__     				= AttnProcsLayers(__UpperCamelCase      )
  return lora_attn_procs, unet_lora_layers



def       __SCREAMING_SNAKE_CASE    (   __UpperCamelCase       :			nn.Module      )				->   str:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__     				= {}
  SCREAMING_SNAKE_CASE__     				= (
      LoRAAttnProcessor2_0 if hasattr(__UpperCamelCase					,	"""scaled_dot_product_attention"""      ) else LoRAAttnProcessor
  )
  for name, module in text_encoder.named_modules():
    if name.endswith(__UpperCamelCase      ):
      SCREAMING_SNAKE_CASE__     				= lora_attn_processor_class(
          hidden_size=module.out_proj.out_features					,	cross_attention_dim=__UpperCamelCase      )
  return text_lora_attn_procs



def       __SCREAMING_SNAKE_CASE    (   __UpperCamelCase       :			nn.Module      )				->   Any:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__     				= create_text_encoder_lora_attn_procs(__UpperCamelCase      )
  SCREAMING_SNAKE_CASE__     				= AttnProcsLayers(__UpperCamelCase      )
  return text_encoder_lora_layers



def       __SCREAMING_SNAKE_CASE    (   __UpperCamelCase       :			Union[str, Any]					,	__UpperCamelCase       :			Tuple=False      )				->   List[Any]:







  """simple docstring"""





  for _, attn_proc in text_lora_attn_procs.items():
    # set up.weights
    for layer_name, layer_module in attn_proc.named_modules():
      if layer_name.endswith("""_lora"""      ):
        SCREAMING_SNAKE_CASE__     				= (
            torch.randn_like(layer_module.up.weight      )
            if randn_weight
            else torch.zeros_like(layer_module.up.weight      )
        )
        SCREAMING_SNAKE_CASE__     				= torch.nn.Parameter(__UpperCamelCase      )







class __snake_case							(		unittest.TestCase						):




   def       __a		(       self     :							int ):



     """simple docstring"""






     torch.manual_seed(0 )
     SCREAMING_SNAKE_CASE__     				= UNetaDConditionModel(
         block_out_channels=(32, 64)			,      layers_per_block=2			,      sample_size=32			,      in_channels=4			,      out_channels=4			,      down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")			,      up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")			,      cross_attention_dim=32			,      )
     SCREAMING_SNAKE_CASE__     				= DDIMScheduler(
         beta_start=0.0_00_85			,      beta_end=0.0_12			,      beta_schedule="""scaled_linear"""			,      clip_sample=_lowercase			,      set_alpha_to_one=_lowercase			,      steps_offset=1			,      )
     torch.manual_seed(0 )
     SCREAMING_SNAKE_CASE__     				= AutoencoderKL(
         block_out_channels=[32, 64]			,      in_channels=3			,      out_channels=3			,      down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]			,      up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]			,      latent_channels=4			,      )
     SCREAMING_SNAKE_CASE__     				= CLIPTextConfig(
         bos_token_id=0			,      eos_token_id=2			,      hidden_size=32			,      intermediate_size=37			,      layer_norm_eps=1E-05			,      num_attention_heads=4			,      num_hidden_layers=5			,      pad_token_id=1			,      vocab_size=10_00			,      )
     SCREAMING_SNAKE_CASE__     				= CLIPTextModel(_lowercase )
     SCREAMING_SNAKE_CASE__     				= CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )

     SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= create_unet_lora_layers(_lowercase )
     SCREAMING_SNAKE_CASE__     				= create_text_encoder_lora_layers(_lowercase )

     SCREAMING_SNAKE_CASE__     				= {
         """unet""": unet,
         """scheduler""": scheduler,
         """vae""": vae,
         """text_encoder""": text_encoder,
         """tokenizer""": tokenizer,
         """safety_checker""": None,
         """feature_extractor""": None,
     }
     SCREAMING_SNAKE_CASE__     				= {
         """unet_lora_layers""": unet_lora_layers,
         """text_encoder_lora_layers""": text_encoder_lora_layers,
         """unet_lora_attn_procs""": unet_lora_attn_procs,
     }
     return pipeline_components, lora_components




   def       __a		(       self     :							str ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__     				= 1
     SCREAMING_SNAKE_CASE__     				= 10
     SCREAMING_SNAKE_CASE__     				= 4
     SCREAMING_SNAKE_CASE__     				= (32, 32)

     SCREAMING_SNAKE_CASE__     				= torch.manual_seed(0 )
     SCREAMING_SNAKE_CASE__     				= floats_tensor((batch_size, num_channels) + sizes )
     SCREAMING_SNAKE_CASE__     				= torch.randint(1			,      _lowercase			,      size=(batch_size, sequence_length)			,      generator=_lowercase )

     SCREAMING_SNAKE_CASE__     				= {
         """prompt""": """A painting of a squirrel eating a burger""",
         """generator""": generator,
         """num_inference_steps""": 2,
         """guidance_scale""": 6.0,
         """output_type""": """numpy""",
     }

     return noise, input_ids, pipeline_inputs

     # copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb




   def       __a		(       self     :							int ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__     				= 77

     SCREAMING_SNAKE_CASE__     				= torch.randint(2			,      56			,      size=(1, max_seq_length)			,      generator=torch.manual_seed(0 ) )

     SCREAMING_SNAKE_CASE__     				= {}
     SCREAMING_SNAKE_CASE__     				= inputs
     return prepared_inputs




   def       __a		(       self     :							Optional[int]			,      _lowercase     :							Union[str, Any] ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= self.get_dummy_components()
     LoraLoaderMixin.save_lora_weights(
         save_directory=_lowercase			,      unet_lora_layers=lora_components["""unet_lora_layers"""]			,      text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]			,      )
     self.assertTrue(os.path.isfile(os.path.join(_lowercase			,      """pytorch_lora_weights.bin""" ) ) )




   def       __a		(       self     :							Any ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= self.get_dummy_components()
     SCREAMING_SNAKE_CASE__     				= StableDiffusionPipeline(**_lowercase )
     SCREAMING_SNAKE_CASE__     				= sd_pipe.to(_lowercase )
     sd_pipe.set_progress_bar_config(disable=_lowercase )

     SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= self.get_dummy_inputs()

     SCREAMING_SNAKE_CASE__     				= sd_pipe(**_lowercase ).images
     SCREAMING_SNAKE_CASE__     				= original_images[0, -3:, -3:, -1]

     with tempfile.TemporaryDirectory() as tmpdirname:
       LoraLoaderMixin.save_lora_weights(
           save_directory=_lowercase			,      unet_lora_layers=lora_components["""unet_lora_layers"""]			,      text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]			,      )
       self.assertTrue(os.path.isfile(os.path.join(_lowercase			,      """pytorch_lora_weights.bin""" ) ) )
       sd_pipe.load_lora_weights(_lowercase )

     SCREAMING_SNAKE_CASE__     				= sd_pipe(**_lowercase ).images
     SCREAMING_SNAKE_CASE__     				= lora_images[0, -3:, -3:, -1]

     # Outputs shouldn't match.
     self.assertFalse(torch.allclose(torch.from_numpy(_lowercase )			,      torch.from_numpy(_lowercase ) ) )




   def       __a		(       self     :							Tuple ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= self.get_dummy_components()
     SCREAMING_SNAKE_CASE__     				= StableDiffusionPipeline(**_lowercase )
     SCREAMING_SNAKE_CASE__     				= sd_pipe.to(_lowercase )
     sd_pipe.set_progress_bar_config(disable=_lowercase )

     SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= self.get_dummy_inputs()

     SCREAMING_SNAKE_CASE__     				= sd_pipe(**_lowercase ).images
     SCREAMING_SNAKE_CASE__     				= original_images[0, -3:, -3:, -1]

     with tempfile.TemporaryDirectory() as tmpdirname:
       LoraLoaderMixin.save_lora_weights(
           save_directory=_lowercase			,      unet_lora_layers=lora_components["""unet_lora_layers"""]			,      text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]			,      safe_serialization=_lowercase			,      )
       self.assertTrue(os.path.isfile(os.path.join(_lowercase			,      """pytorch_lora_weights.safetensors""" ) ) )
       sd_pipe.load_lora_weights(_lowercase )

     SCREAMING_SNAKE_CASE__     				= sd_pipe(**_lowercase ).images
     SCREAMING_SNAKE_CASE__     				= lora_images[0, -3:, -3:, -1]

     # Outputs shouldn't match.
     self.assertFalse(torch.allclose(torch.from_numpy(_lowercase )			,      torch.from_numpy(_lowercase ) ) )




   def       __a		(       self     :							Any ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= self.get_dummy_components()
     SCREAMING_SNAKE_CASE__     				= lora_components["""unet_lora_attn_procs"""]
     SCREAMING_SNAKE_CASE__     				= StableDiffusionPipeline(**_lowercase )
     SCREAMING_SNAKE_CASE__     				= sd_pipe.to(_lowercase )
     sd_pipe.set_progress_bar_config(disable=_lowercase )

     SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= self.get_dummy_inputs()

     SCREAMING_SNAKE_CASE__     				= sd_pipe(**_lowercase ).images
     SCREAMING_SNAKE_CASE__     				= original_images[0, -3:, -3:, -1]

     with tempfile.TemporaryDirectory() as tmpdirname:
       SCREAMING_SNAKE_CASE__     				= sd_pipe.unet
       unet.set_attn_processor(_lowercase )
       unet.save_attn_procs(_lowercase )
       self.assertTrue(os.path.isfile(os.path.join(_lowercase			,      """pytorch_lora_weights.bin""" ) ) )
       sd_pipe.load_lora_weights(_lowercase )

     SCREAMING_SNAKE_CASE__     				= sd_pipe(**_lowercase ).images
     SCREAMING_SNAKE_CASE__     				= lora_images[0, -3:, -3:, -1]

     # Outputs shouldn't match.
     self.assertFalse(torch.allclose(torch.from_numpy(_lowercase )			,      torch.from_numpy(_lowercase ) ) )




   def       __a		(       self     :							Tuple ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= self.get_dummy_components()
     SCREAMING_SNAKE_CASE__     				= StableDiffusionPipeline(**_lowercase )

     SCREAMING_SNAKE_CASE__     				= self.get_dummy_tokens()

     # inference without lora
     SCREAMING_SNAKE_CASE__     				= pipe.text_encoder(**_lowercase )[0]
     assert outputs_without_lora.shape == (1, 77, 32)

     # create lora_attn_procs with zeroed out up.weights
     SCREAMING_SNAKE_CASE__     				= create_text_encoder_lora_attn_procs(pipe.text_encoder )
     set_lora_up_weights(_lowercase			,      randn_weight=_lowercase )

     # monkey patch
     pipe._modify_text_encoder(_lowercase )

     # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
     del text_attn_procs
     gc.collect()

     # inference with lora
     SCREAMING_SNAKE_CASE__     				= pipe.text_encoder(**_lowercase )[0]
     assert outputs_with_lora.shape == (1, 77, 32)

     assert torch.allclose(
         _lowercase			,      _lowercase ), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"

     # create lora_attn_procs with randn up.weights
     SCREAMING_SNAKE_CASE__     				= create_text_encoder_lora_attn_procs(pipe.text_encoder )
     set_lora_up_weights(_lowercase			,      randn_weight=_lowercase )

     # monkey patch
     pipe._modify_text_encoder(_lowercase )

     # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
     del text_attn_procs
     gc.collect()

     # inference with lora
     SCREAMING_SNAKE_CASE__     				= pipe.text_encoder(**_lowercase )[0]
     assert outputs_with_lora.shape == (1, 77, 32)

     assert not torch.allclose(
         _lowercase			,      _lowercase ), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"




   def       __a		(       self     :							str ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= self.get_dummy_components()
     SCREAMING_SNAKE_CASE__     				= StableDiffusionPipeline(**_lowercase )

     SCREAMING_SNAKE_CASE__     				= self.get_dummy_tokens()

     # inference without lora
     SCREAMING_SNAKE_CASE__     				= pipe.text_encoder(**_lowercase )[0]
     assert outputs_without_lora.shape == (1, 77, 32)

     # create lora_attn_procs with randn up.weights
     SCREAMING_SNAKE_CASE__     				= create_text_encoder_lora_attn_procs(pipe.text_encoder )
     set_lora_up_weights(_lowercase			,      randn_weight=_lowercase )

     # monkey patch
     pipe._modify_text_encoder(_lowercase )

     # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
     del text_attn_procs
     gc.collect()

     # inference with lora
     SCREAMING_SNAKE_CASE__     				= pipe.text_encoder(**_lowercase )[0]
     assert outputs_with_lora.shape == (1, 77, 32)

     assert not torch.allclose(
         _lowercase			,      _lowercase ), "lora outputs should be different to without lora outputs"

     # remove monkey patch
     pipe._remove_text_encoder_monkey_patch()

     # inference with removed lora
     SCREAMING_SNAKE_CASE__     				= pipe.text_encoder(**_lowercase )[0]
     assert outputs_without_lora_removed.shape == (1, 77, 32)

     assert torch.allclose(
         _lowercase			,      _lowercase ), "remove lora monkey patch should restore the original outputs"




   def       __a		(       self     :							Tuple ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= self.get_dummy_components()
     SCREAMING_SNAKE_CASE__     				= StableDiffusionPipeline(**_lowercase )
     SCREAMING_SNAKE_CASE__     				= sd_pipe.to(_lowercase )
     sd_pipe.set_progress_bar_config(disable=_lowercase )

     SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= self.get_dummy_inputs()

     with tempfile.TemporaryDirectory() as tmpdirname:
       LoraLoaderMixin.save_lora_weights(
           save_directory=_lowercase			,      unet_lora_layers=lora_components["""unet_lora_layers"""]			,      text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]			,      )
       self.assertTrue(os.path.isfile(os.path.join(_lowercase			,      """pytorch_lora_weights.bin""" ) ) )
       sd_pipe.load_lora_weights(_lowercase )

     SCREAMING_SNAKE_CASE__     				= sd_pipe(**_lowercase ).images
     SCREAMING_SNAKE_CASE__     				= lora_images[0, -3:, -3:, -1]

     SCREAMING_SNAKE_CASE__     				= sd_pipe(**_lowercase			,      cross_attention_kwargs={"""scale""": 0.5} ).images
     SCREAMING_SNAKE_CASE__     				= lora_images_with_scale[0, -3:, -3:, -1]

     # Outputs shouldn't match.
     self.assertFalse(
         torch.allclose(torch.from_numpy(_lowercase )			,      torch.from_numpy(_lowercase ) ) )




   def       __a		(       self     :							List[Any] ):



     """simple docstring"""






     with tempfile.TemporaryDirectory() as tmpdirname:
       self.create_lora_weight_file(_lowercase )

       SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= self.get_dummy_components()
       SCREAMING_SNAKE_CASE__     				= StableDiffusionPipeline(**_lowercase )
       SCREAMING_SNAKE_CASE__     				= sd_pipe.to(_lowercase )
       sd_pipe.set_progress_bar_config(disable=_lowercase )

       # check if vanilla attention processors are used
       for _, module in sd_pipe.unet.named_modules():
         if isinstance(_lowercase			,      _lowercase ):
           self.assertIsInstance(module.processor			,      (AttnProcessor, AttnProcessor2_0) )

            # load LoRA weight file
       sd_pipe.load_lora_weights(_lowercase )

       # check if lora attention processors are used
       for _, module in sd_pipe.unet.named_modules():
         if isinstance(_lowercase			,      _lowercase ):
           SCREAMING_SNAKE_CASE__     				= (
               LoRAAttnProcessor2_0 if hasattr(_lowercase			,      """scaled_dot_product_attention""" ) else LoRAAttnProcessor
           )
           self.assertIsInstance(module.processor			,      _lowercase )




   @unittest.skipIf(torch_device != """cuda"""			,      """This test is supposed to run on GPU""" )
   def       __a		(       self     :							List[str] ):



     """simple docstring"""






     with tempfile.TemporaryDirectory() as tmpdirname:
       self.create_lora_weight_file(_lowercase )

       SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= self.get_dummy_components()
       SCREAMING_SNAKE_CASE__     				= StableDiffusionPipeline(**_lowercase )
       SCREAMING_SNAKE_CASE__     				= sd_pipe.to(_lowercase )
       sd_pipe.set_progress_bar_config(disable=_lowercase )

       # enable XFormers
       sd_pipe.enable_xformers_memory_efficient_attention()

       # check if xFormers attention processors are used
       for _, module in sd_pipe.unet.named_modules():
         if isinstance(_lowercase			,      _lowercase ):
           self.assertIsInstance(module.processor			,      _lowercase )

            # load LoRA weight file
       sd_pipe.load_lora_weights(_lowercase )

       # check if lora attention processors are used
       for _, module in sd_pipe.unet.named_modules():
         if isinstance(_lowercase			,      _lowercase ):
           self.assertIsInstance(module.processor			,      _lowercase )




   @unittest.skipIf(torch_device != """cuda"""			,      """This test is supposed to run on GPU""" )
   def       __a		(       self     :							List[Any] ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= self.get_dummy_components()
     SCREAMING_SNAKE_CASE__     				= StableDiffusionPipeline(**_lowercase )
     SCREAMING_SNAKE_CASE__     				= sd_pipe.to(_lowercase )
     sd_pipe.set_progress_bar_config(disable=_lowercase )

     SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__				,	SCREAMING_SNAKE_CASE__     				= self.get_dummy_inputs()

     # enable XFormers
     sd_pipe.enable_xformers_memory_efficient_attention()

     SCREAMING_SNAKE_CASE__     				= sd_pipe(**_lowercase ).images
     SCREAMING_SNAKE_CASE__     				= original_images[0, -3:, -3:, -1]

     with tempfile.TemporaryDirectory() as tmpdirname:
       LoraLoaderMixin.save_lora_weights(
           save_directory=_lowercase			,      unet_lora_layers=lora_components["""unet_lora_layers"""]			,      text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]			,      )
       self.assertTrue(os.path.isfile(os.path.join(_lowercase			,      """pytorch_lora_weights.bin""" ) ) )
       sd_pipe.load_lora_weights(_lowercase )

     SCREAMING_SNAKE_CASE__     				= sd_pipe(**_lowercase ).images
     SCREAMING_SNAKE_CASE__     				= lora_images[0, -3:, -3:, -1]

     # Outputs shouldn't match.
     self.assertFalse(torch.allclose(torch.from_numpy(_lowercase )			,      torch.from_numpy(_lowercase ) ) )

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__lowerCamelCase     :					Optional[int]				  =						{'''configuration_vilt''': ['''VILT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ViltConfig''']}

try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   __lowerCamelCase     :					Dict				  =						['''ViltFeatureExtractor''']
   __lowerCamelCase     :					Dict				  =						['''ViltImageProcessor''']
   __lowerCamelCase     :					str				  =						['''ViltProcessor''']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   __lowerCamelCase     :					Any				  =						[
       '''VILT_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''ViltForImageAndTextRetrieval''',
       '''ViltForImagesAndTextClassification''',
       '''ViltForTokenClassification''',
       '''ViltForMaskedLM''',
       '''ViltForQuestionAnswering''',
       '''ViltLayer''',
       '''ViltModel''',
       '''ViltPreTrainedModel''',
   ]


if TYPE_CHECKING:
   from .configuration_vilt import VILT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViltConfig

   try:
      if not is_vision_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .feature_extraction_vilt import ViltFeatureExtractor
      from .image_processing_vilt import ViltImageProcessor
      from .processing_vilt import ViltProcessor

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_vilt import (
          VILT_PRETRAINED_MODEL_ARCHIVE_LIST,
          ViltForImageAndTextRetrieval,
          ViltForImagesAndTextClassification,
          ViltForMaskedLM,
          ViltForQuestionAnswering,
          ViltForTokenClassification,
          ViltLayer,
          ViltModel,
          ViltPreTrainedModel,
      )


else:
   import sys

   __lowerCamelCase     :					List[str]				  =						_LazyModule(__name__, globals()['''__file__'''], _import_structure)
