





'''simple docstring'''







import os
import tempfile
import unittest

import numpy as np
import torch

from diffusers.models import ModelMixin, UNetaDConditionModel
from diffusers.models.attention_processor import AttnProcessor, LoRAAttnProcessor
from diffusers.utils import (
    floats_tensor,
    logging,
    skip_mps,
    torch_device,
)
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()

snake_case_       :    Optional[int]          =					logging.get_logger(__name__)





def     lowerCamelCase_ (					SCREAMING_SNAKE_CASE__ :     Dict,     SCREAMING_SNAKE_CASE__ :     bool = True				)	->		Tuple:
						UpperCAmelCase_     : List[str]         =					{}
						for name in model.attn_processors.keys():
												UpperCAmelCase_     : int         =					name.endswith('''attn2.processor'''				) and not (
												    name.startswith('''transformer_in'''				) or '''temp_attentions''' in name.split('''.'''				)
												)
												UpperCAmelCase_     : Dict         =					model.config.cross_attention_dim if has_cross_attention else None
												if name.startswith('''mid_block'''				):
																		UpperCAmelCase_     : Optional[int]         =					model.config.block_out_channels[-1]
												elif name.startswith('''up_blocks'''				):
																		UpperCAmelCase_     : int         =					int(name[len('''up_blocks.'''				)]				)
																		UpperCAmelCase_     : Optional[int]         =					list(reversed(model.config.block_out_channels				)				)[block_id]
												elif name.startswith('''down_blocks'''				):
																		UpperCAmelCase_     : str         =					int(name[len('''down_blocks.'''				)]				)
																		UpperCAmelCase_     : str         =					model.config.block_out_channels[block_id]
												elif name.startswith('''transformer_in'''				):
																		# Note that the `8 * ...` comes from: https://github.com/huggingface/diffusers/blob/7139f0e874f10b2463caa8cbd585762a309d12d6/src/diffusers/models/unet_3d_condition.py#L148
																		UpperCAmelCase_     : Any         =					8 * model.config.attention_head_dim

												UpperCAmelCase_     : Any         =					LoRAAttnProcessor(hidden_size=_lowerCamelCase,     cross_attention_dim=_lowerCamelCase				)
												UpperCAmelCase_     : Any         =					lora_attn_procs[name].to(model.device				)

												if mock_weights:
																		# add 1 to weights to mock trained weights
																		with torch.no_grad():
																								lora_attn_procs[name].to_q_lora.up.weight += 1
																								lora_attn_procs[name].to_k_lora.up.weight += 1
																								lora_attn_procs[name].to_v_lora.up.weight += 1
																								lora_attn_procs[name].to_out_lora.up.weight += 1

						return lora_attn_procs


@skip_mps
class    __a (__lowerCAmelCase    ,						__lowerCAmelCase    ,						unittest.TestCase       ):
	__a   :				Union[str, Any]       =    UNetaDConditionModel
	__a   :				Tuple       =    '''sample'''

	@property
	def       UpperCAmelCase__		(							self							:       Union[str, Any]				)   ->    List[Any]:







							"""simple docstring"""
							UpperCAmelCase_     : List[Any]         =					4
							UpperCAmelCase_     : List[str]         =					4
							UpperCAmelCase_     : List[Any]         =					4
							UpperCAmelCase_     : int         =					(32, 32)

							UpperCAmelCase_     : int         =					floats_tensor((batch_size, num_channels, num_frames) + sizes				).to(__SCREAMING_SNAKE_CASE				)
							UpperCAmelCase_     : Optional[int]         =					torch.tensor([10]				).to(__SCREAMING_SNAKE_CASE				)
							UpperCAmelCase_     : Tuple         =					floats_tensor((batch_size, 4, 32)				).to(__SCREAMING_SNAKE_CASE				)

							return {"sample": noise, "timestep": time_step, "encoder_hidden_states": encoder_hidden_states}

	@property
	def       UpperCAmelCase__		(							self							:       Union[str, Any]				)   ->    List[str]:







							"""simple docstring"""
							return (4, 4, 32, 32)

	@property
	def       UpperCAmelCase__		(							self							:       Any				)   ->    str:







							"""simple docstring"""
							return (4, 4, 32, 32)

	def       UpperCAmelCase__		(							self							:       List[str]				)   ->    List[Any]:







							"""simple docstring"""
							UpperCAmelCase_     : Optional[Any]         =					{
							    '''block_out_channels''': (32, 64),
							    '''down_block_types''': (
							        '''CrossAttnDownBlock3D''',
							        '''DownBlock3D''',
							    ),
							    '''up_block_types''': ('''UpBlock3D''', '''CrossAttnUpBlock3D'''),
							    '''cross_attention_dim''': 32,
							    '''attention_head_dim''': 8,
							    '''out_channels''': 4,
							    '''in_channels''': 4,
							    '''layers_per_block''': 1,
							    '''sample_size''': 32,
							}
							UpperCAmelCase_     : List[Any]         =					self.dummy_input
							return init_dict, inputs_dict

	@unittest.skipIf(
	    torch_device != '''cuda''' or not is_xformers_available()    ,       reason='''XFormers attention is only available with CUDA and `xformers` installed'''    ,       )
	def       UpperCAmelCase__		(							self							:       int				)   ->    Tuple:







							"""simple docstring"""
							UpperCAmelCase_  ,    UpperCAmelCase_     : List[str]         =					self.prepare_init_args_and_inputs_for_common()
							UpperCAmelCase_     : Union[str, Any]         =					self.model_class(**__SCREAMING_SNAKE_CASE				)

							model.enable_xformers_memory_efficient_attention()

							assert (
							    model.mid_block.attentions[0].transformer_blocks[0].attna.processor.__class__.__name__
							    == "XFormersAttnProcessor"
							), "xformers is not enabled"

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







							"""simple docstring"""
							UpperCAmelCase_  ,    UpperCAmelCase_     : Any         =					self.prepare_init_args_and_inputs_for_common()

							UpperCAmelCase_     : str         =					32

							UpperCAmelCase_     : List[Any]         =					self.model_class(**__SCREAMING_SNAKE_CASE				)
							model.to(__SCREAMING_SNAKE_CASE				)
							model.eval()

							with torch.no_grad():
													UpperCAmelCase_     : Any         =					model(**__SCREAMING_SNAKE_CASE				)

													if isinstance(__SCREAMING_SNAKE_CASE    ,       __SCREAMING_SNAKE_CASE				):
																			UpperCAmelCase_     : Optional[Any]         =					output.sample

							self.assertIsNotNone(__SCREAMING_SNAKE_CASE				)
							UpperCAmelCase_     : Tuple         =					inputs_dict['''sample'''].shape
							self.assertEqual(output.shape    ,       __SCREAMING_SNAKE_CASE    ,       '''Input and output shapes do not match'''				)

	def       UpperCAmelCase__		(							self							:       Union[str, Any]				)   ->    Optional[int]:







							"""simple docstring"""
							UpperCAmelCase_  ,    UpperCAmelCase_     : Optional[Any]         =					self.prepare_init_args_and_inputs_for_common()
							UpperCAmelCase_     : Union[str, Any]         =					self.model_class(**__SCREAMING_SNAKE_CASE				)
							model.to(__SCREAMING_SNAKE_CASE				)
							model.eval()

							with torch.no_grad():
													# Warmup pass when using mps (see #372)
													if torch_device == "mps" and isinstance(__SCREAMING_SNAKE_CASE    ,       __SCREAMING_SNAKE_CASE				):
																			model(**self.dummy_input				)

													UpperCAmelCase_     : Optional[Any]         =					model(**__SCREAMING_SNAKE_CASE				)
													if isinstance(__SCREAMING_SNAKE_CASE    ,       __SCREAMING_SNAKE_CASE				):
																			UpperCAmelCase_     : Optional[Any]         =					first.sample

													UpperCAmelCase_     : List[str]         =					model(**__SCREAMING_SNAKE_CASE				)
													if isinstance(__SCREAMING_SNAKE_CASE    ,       __SCREAMING_SNAKE_CASE				):
																			UpperCAmelCase_     : Any         =					second.sample

							UpperCAmelCase_     : Dict         =					first.cpu().numpy()
							UpperCAmelCase_     : Dict         =					second.cpu().numpy()
							UpperCAmelCase_     : Optional[int]         =					out_a[~np.isnan(__SCREAMING_SNAKE_CASE				)]
							UpperCAmelCase_     : Dict         =					out_a[~np.isnan(__SCREAMING_SNAKE_CASE				)]
							UpperCAmelCase_     : Optional[int]         =					np.amax(np.abs(out_a - out_a				)				)
							self.assertLessEqual(__SCREAMING_SNAKE_CASE    ,       1E-5				)

	def       UpperCAmelCase__		(							self							:       Dict				)   ->    Dict:







							"""simple docstring"""
							UpperCAmelCase_  ,    UpperCAmelCase_     : Union[str, Any]         =					self.prepare_init_args_and_inputs_for_common()

							UpperCAmelCase_     : int         =					8

							UpperCAmelCase_     : Optional[Any]         =					self.model_class(**__SCREAMING_SNAKE_CASE				)
							model.to(__SCREAMING_SNAKE_CASE				)
							model.eval()

							model.set_attention_slice('''auto'''				)
							with torch.no_grad():
													UpperCAmelCase_     : int         =					model(**__SCREAMING_SNAKE_CASE				)
							assert output is not None

							model.set_attention_slice('''max'''				)
							with torch.no_grad():
													UpperCAmelCase_     : Optional[int]         =					model(**__SCREAMING_SNAKE_CASE				)
							assert output is not None

							model.set_attention_slice(2				)
							with torch.no_grad():
													UpperCAmelCase_     : Tuple         =					model(**__SCREAMING_SNAKE_CASE				)
							assert output is not None

	def       UpperCAmelCase__		(							self							:       str				)   ->    List[Any]:







							"""simple docstring"""
							UpperCAmelCase_  ,    UpperCAmelCase_     : Union[str, Any]         =					self.prepare_init_args_and_inputs_for_common()

							UpperCAmelCase_     : int         =					8

							UpperCAmelCase_     : Union[str, Any]         =					self.model_class(**__SCREAMING_SNAKE_CASE				)
							model.to(__SCREAMING_SNAKE_CASE				)

							with torch.no_grad():
													UpperCAmelCase_     : Optional[int]         =					model(**__SCREAMING_SNAKE_CASE				).sample

							UpperCAmelCase_     : Tuple         =					create_lora_layers(__SCREAMING_SNAKE_CASE				)

							# make sure we can set a list of attention processors
							model.set_attn_processor(__SCREAMING_SNAKE_CASE				)
							model.to(__SCREAMING_SNAKE_CASE				)

							# test that attn processors can be set to itself
							model.set_attn_processor(model.attn_processors				)

							with torch.no_grad():
													UpperCAmelCase_     : List[str]         =					model(**__SCREAMING_SNAKE_CASE    ,       cross_attention_kwargs={'''scale''': 0.0}				).sample
													UpperCAmelCase_     : Union[str, Any]         =					model(**__SCREAMING_SNAKE_CASE    ,       cross_attention_kwargs={'''scale''': 0.5}				).sample
													UpperCAmelCase_     : Union[str, Any]         =					model(**__SCREAMING_SNAKE_CASE    ,       cross_attention_kwargs={'''scale''': 0.5}				).sample

							assert (samplea - samplea).abs().max() < 3E-3
							assert (samplea - samplea).abs().max() < 3E-3

							# sample 2 and sample 3 should be different
							assert (samplea - samplea).abs().max() > 3E-3

	def       UpperCAmelCase__		(							self							:       Optional[int]				)   ->    Tuple:







							"""simple docstring"""
							UpperCAmelCase_  ,    UpperCAmelCase_     : Any         =					self.prepare_init_args_and_inputs_for_common()

							UpperCAmelCase_     : Union[str, Any]         =					8

							torch.manual_seed(0				)
							UpperCAmelCase_     : Dict         =					self.model_class(**__SCREAMING_SNAKE_CASE				)
							model.to(__SCREAMING_SNAKE_CASE				)

							with torch.no_grad():
													UpperCAmelCase_     : Union[str, Any]         =					model(**__SCREAMING_SNAKE_CASE				).sample

							UpperCAmelCase_     : Dict         =					create_lora_layers(__SCREAMING_SNAKE_CASE				)
							model.set_attn_processor(__SCREAMING_SNAKE_CASE				)

							with torch.no_grad():
													UpperCAmelCase_     : str         =					model(**__SCREAMING_SNAKE_CASE    ,       cross_attention_kwargs={'''scale''': 0.5}				).sample

							with tempfile.TemporaryDirectory() as tmpdirname:
													model.save_attn_procs(__SCREAMING_SNAKE_CASE				)
													self.assertTrue(os.path.isfile(os.path.join(__SCREAMING_SNAKE_CASE    ,       '''pytorch_lora_weights.bin'''				)				)				)
													torch.manual_seed(0				)
													UpperCAmelCase_     : Union[str, Any]         =					self.model_class(**__SCREAMING_SNAKE_CASE				)
													new_model.to(__SCREAMING_SNAKE_CASE				)
													new_model.load_attn_procs(__SCREAMING_SNAKE_CASE				)

							with torch.no_grad():
													UpperCAmelCase_     : Dict         =					new_model(**__SCREAMING_SNAKE_CASE    ,       cross_attention_kwargs={'''scale''': 0.5}				).sample

							assert (sample - new_sample).abs().max() < 1E-3

							# LoRA and no LoRA should NOT be the same
							assert (sample - old_sample).abs().max() > 1E-4

	def       UpperCAmelCase__		(							self							:       List[Any]				)   ->    List[Any]:







							"""simple docstring"""
							UpperCAmelCase_  ,    UpperCAmelCase_     : List[Any]         =					self.prepare_init_args_and_inputs_for_common()

							UpperCAmelCase_     : Optional[Any]         =					8

							torch.manual_seed(0				)
							UpperCAmelCase_     : Any         =					self.model_class(**__SCREAMING_SNAKE_CASE				)
							model.to(__SCREAMING_SNAKE_CASE				)

							with torch.no_grad():
													UpperCAmelCase_     : Any         =					model(**__SCREAMING_SNAKE_CASE				).sample

							UpperCAmelCase_     : Any         =					create_lora_layers(__SCREAMING_SNAKE_CASE				)
							model.set_attn_processor(__SCREAMING_SNAKE_CASE				)

							with torch.no_grad():
													UpperCAmelCase_     : Dict         =					model(**__SCREAMING_SNAKE_CASE    ,       cross_attention_kwargs={'''scale''': 0.5}				).sample

							with tempfile.TemporaryDirectory() as tmpdirname:
													model.save_attn_procs(__SCREAMING_SNAKE_CASE    ,       safe_serialization=__SCREAMING_SNAKE_CASE				)
													self.assertTrue(os.path.isfile(os.path.join(__SCREAMING_SNAKE_CASE    ,       '''pytorch_lora_weights.safetensors'''				)				)				)
													torch.manual_seed(0				)
													UpperCAmelCase_     : List[str]         =					self.model_class(**__SCREAMING_SNAKE_CASE				)
													new_model.to(__SCREAMING_SNAKE_CASE				)
													new_model.load_attn_procs(__SCREAMING_SNAKE_CASE				)

							with torch.no_grad():
													UpperCAmelCase_     : Union[str, Any]         =					new_model(**__SCREAMING_SNAKE_CASE    ,       cross_attention_kwargs={'''scale''': 0.5}				).sample

							assert (sample - new_sample).abs().max() < 3E-3

							# LoRA and no LoRA should NOT be the same
							assert (sample - old_sample).abs().max() > 1E-4

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







							"""simple docstring"""
							UpperCAmelCase_  ,    UpperCAmelCase_     : List[Any]         =					self.prepare_init_args_and_inputs_for_common()

							UpperCAmelCase_     : List[Any]         =					8

							torch.manual_seed(0				)
							UpperCAmelCase_     : str         =					self.model_class(**__SCREAMING_SNAKE_CASE				)
							model.to(__SCREAMING_SNAKE_CASE				)

							UpperCAmelCase_     : int         =					create_lora_layers(__SCREAMING_SNAKE_CASE    ,       mock_weights=__SCREAMING_SNAKE_CASE				)
							model.set_attn_processor(__SCREAMING_SNAKE_CASE				)
							# Saving as torch, properly reloads with directly filename
							with tempfile.TemporaryDirectory() as tmpdirname:
													model.save_attn_procs(__SCREAMING_SNAKE_CASE				)
													self.assertTrue(os.path.isfile(os.path.join(__SCREAMING_SNAKE_CASE    ,       '''pytorch_lora_weights.bin'''				)				)				)
													torch.manual_seed(0				)
													UpperCAmelCase_     : str         =					self.model_class(**__SCREAMING_SNAKE_CASE				)
													new_model.to(__SCREAMING_SNAKE_CASE				)
													new_model.load_attn_procs(__SCREAMING_SNAKE_CASE    ,       weight_name='''pytorch_lora_weights.bin'''				)

	def       UpperCAmelCase__		(							self							:       List[Any]				)   ->    str:







							"""simple docstring"""
							UpperCAmelCase_  ,    UpperCAmelCase_     : str         =					self.prepare_init_args_and_inputs_for_common()

							UpperCAmelCase_     : Tuple         =					8

							torch.manual_seed(0				)
							UpperCAmelCase_     : str         =					self.model_class(**__SCREAMING_SNAKE_CASE				)
							model.to(__SCREAMING_SNAKE_CASE				)

							UpperCAmelCase_     : int         =					create_lora_layers(__SCREAMING_SNAKE_CASE    ,       mock_weights=__SCREAMING_SNAKE_CASE				)
							model.set_attn_processor(__SCREAMING_SNAKE_CASE				)
							# Saving as torch, properly reloads with directly filename
							with tempfile.TemporaryDirectory() as tmpdirname:
													model.save_attn_procs(__SCREAMING_SNAKE_CASE				)
													self.assertTrue(os.path.isfile(os.path.join(__SCREAMING_SNAKE_CASE    ,       '''pytorch_lora_weights.bin'''				)				)				)
													torch.manual_seed(0				)
													UpperCAmelCase_     : Optional[Any]         =					self.model_class(**__SCREAMING_SNAKE_CASE				)
													new_model.to(__SCREAMING_SNAKE_CASE				)
													with self.assertRaises(__SCREAMING_SNAKE_CASE				) as e:
																			new_model.load_attn_procs(__SCREAMING_SNAKE_CASE    ,       use_safetensors=__SCREAMING_SNAKE_CASE				)
													self.assertIn('''Error no file named pytorch_lora_weights.safetensors'''    ,       str(e.exception				)				)

	def       UpperCAmelCase__		(							self							:       List[Any]				)   ->    Any:







							"""simple docstring"""
							UpperCAmelCase_  ,    UpperCAmelCase_     : int         =					self.prepare_init_args_and_inputs_for_common()

							UpperCAmelCase_     : List[Any]         =					8

							torch.manual_seed(0				)
							UpperCAmelCase_     : List[str]         =					self.model_class(**__SCREAMING_SNAKE_CASE				)
							model.to(__SCREAMING_SNAKE_CASE				)

							with torch.no_grad():
													UpperCAmelCase_     : Any         =					model(**__SCREAMING_SNAKE_CASE				).sample

							UpperCAmelCase_     : Tuple         =					create_lora_layers(__SCREAMING_SNAKE_CASE				)
							model.set_attn_processor(__SCREAMING_SNAKE_CASE				)

							with torch.no_grad():
													UpperCAmelCase_     : Union[str, Any]         =					model(**__SCREAMING_SNAKE_CASE    ,       cross_attention_kwargs={'''scale''': 0.0}				).sample

							model.set_attn_processor(AttnProcessor()				)

							with torch.no_grad():
													UpperCAmelCase_     : Tuple         =					model(**__SCREAMING_SNAKE_CASE				).sample

							assert (sample - new_sample).abs().max() < 1E-4
							assert (sample - old_sample).abs().max() < 3E-3

	@unittest.skipIf(
	    torch_device != '''cuda''' or not is_xformers_available()    ,       reason='''XFormers attention is only available with CUDA and `xformers` installed'''    ,       )
	def       UpperCAmelCase__		(							self							:       str				)   ->    Any:







							"""simple docstring"""
							UpperCAmelCase_  ,    UpperCAmelCase_     : List[Any]         =					self.prepare_init_args_and_inputs_for_common()

							UpperCAmelCase_     : Optional[int]         =					4

							torch.manual_seed(0				)
							UpperCAmelCase_     : int         =					self.model_class(**__SCREAMING_SNAKE_CASE				)
							model.to(__SCREAMING_SNAKE_CASE				)
							UpperCAmelCase_     : Any         =					create_lora_layers(__SCREAMING_SNAKE_CASE				)
							model.set_attn_processor(__SCREAMING_SNAKE_CASE				)

							# default
							with torch.no_grad():
													UpperCAmelCase_     : List[str]         =					model(**__SCREAMING_SNAKE_CASE				).sample

													model.enable_xformers_memory_efficient_attention()
													UpperCAmelCase_     : Tuple         =					model(**__SCREAMING_SNAKE_CASE				).sample

													model.disable_xformers_memory_efficient_attention()
													UpperCAmelCase_     : Dict         =					model(**__SCREAMING_SNAKE_CASE				).sample

							assert (sample - on_sample).abs().max() < 1E-4
							assert (sample - off_sample).abs().max() < 1E-4



	def       UpperCAmelCase__		(							self							:       str				)   ->    str:







							"""simple docstring"""
							UpperCAmelCase_  ,    UpperCAmelCase_     : str         =					self.prepare_init_args_and_inputs_for_common()
							UpperCAmelCase_     : List[str]         =					32

							UpperCAmelCase_     : List[Any]         =					self.model_class(**__SCREAMING_SNAKE_CASE				)
							model.to(__SCREAMING_SNAKE_CASE				)
							model.eval()

							with torch.no_grad():
													UpperCAmelCase_     : Union[str, Any]         =					model(**__SCREAMING_SNAKE_CASE				)[0]

							model.enable_forward_chunking()
							with torch.no_grad():
													UpperCAmelCase_     : List[str]         =					model(**__SCREAMING_SNAKE_CASE				)[0]

							self.assertEqual(output.shape    ,       output_a.shape    ,       '''Shape doesn\'t match'''				)
							assert np.abs(output.cpu() - output_a.cpu()				).max() < 1E-2


# (todo: sayakpaul) implement SLOW tests.












'''simple docstring'''







# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

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


snake_case_       :    List[Any]          =					{
    "configuration_tvlt": ["TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP", "TvltConfig"],
    "feature_extraction_tvlt": ["TvltFeatureExtractor"],
    "processing_tvlt": ["TvltProcessor"],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_       :    Optional[int]          =					[
					    "TVLT_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "TvltModel",
					    "TvltForPreTraining",
					    "TvltForAudioVisualClassification",
					    "TvltPreTrainedModel",
					]

try:
					if not is_vision_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_       :    List[Any]          =					["TvltImageProcessor"]


if TYPE_CHECKING:
					from .configuration_tvlt import TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP, TvltConfig
					from .processing_tvlt import TvltProcessor
					from .feature_extraction_tvlt import TvltFeatureExtractor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tvlt import (
										    TVLT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TvltForAudioVisualClassification,
										    TvltForPreTraining,
										    TvltModel,
										    TvltPreTrainedModel,
										)

					try:
										if not is_vision_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .image_processing_tvlt import TvltImageProcessor


else:
					import sys

					snake_case_       :    Any          =					_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





