



from typing import TYPE_CHECKING

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


lowerCAmelCase__					  =  {
    '''configuration_clip''': [
        '''CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''CLIPConfig''',
        '''CLIPOnnxConfig''',
        '''CLIPTextConfig''',
        '''CLIPVisionConfig''',
    ],
    '''processing_clip''': ['''CLIPProcessor'''],
    '''tokenization_clip''': ['''CLIPTokenizer'''],
}

try:
				if not is_tokenizers_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowerCAmelCase__					  =  ['''CLIPTokenizerFast''']

try:
				if not is_vision_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowerCAmelCase__					  =  ['''CLIPFeatureExtractor''']
				lowerCAmelCase__					  =  ['''CLIPImageProcessor''']

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowerCAmelCase__					  =  [
				    '''CLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''CLIPModel''',
				    '''CLIPPreTrainedModel''',
				    '''CLIPTextModel''',
				    '''CLIPTextModelWithProjection''',
				    '''CLIPVisionModel''',
				    '''CLIPVisionModelWithProjection''',
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowerCAmelCase__					  =  [
				    '''TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''TFCLIPModel''',
				    '''TFCLIPPreTrainedModel''',
				    '''TFCLIPTextModel''',
				    '''TFCLIPVisionModel''',
				]

try:
				if not is_flax_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowerCAmelCase__					  =  [
				    '''FlaxCLIPModel''',
				    '''FlaxCLIPPreTrainedModel''',
				    '''FlaxCLIPTextModel''',
				    '''FlaxCLIPTextPreTrainedModel''',
				    '''FlaxCLIPVisionModel''',
				    '''FlaxCLIPVisionPreTrainedModel''',
				]


if TYPE_CHECKING:
				from .configuration_clip import (
				    CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
				    CLIPConfig,
				    CLIPOnnxConfig,
				    CLIPTextConfig,
				    CLIPVisionConfig,
				)
				from .processing_clip import CLIPProcessor
				from .tokenization_clip import CLIPTokenizer

				try:
								if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_clip_fast import CLIPTokenizerFast

				try:
								if not is_vision_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .feature_extraction_clip import CLIPFeatureExtractor
								from .image_processing_clip import CLIPImageProcessor

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_clip import (
								    CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
								    CLIPModel,
								    CLIPPreTrainedModel,
								    CLIPTextModel,
								    CLIPTextModelWithProjection,
								    CLIPVisionModel,
								    CLIPVisionModelWithProjection,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_clip import (
								    TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFCLIPModel,
								    TFCLIPPreTrainedModel,
								    TFCLIPTextModel,
								    TFCLIPVisionModel,
								)

				try:
								if not is_flax_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_flax_clip import (
								    FlaxCLIPModel,
								    FlaxCLIPPreTrainedModel,
								    FlaxCLIPTextModel,
								    FlaxCLIPTextPreTrainedModel,
								    FlaxCLIPVisionModel,
								    FlaxCLIPVisionPreTrainedModel,
								)


else:
				import sys

				lowerCAmelCase__					  =  _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)









import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()

class 				snake_case__(unittest.TestCase      ):

					"""simple docstring"""






					@property
					def 			snake_case					(							self :     Any					):
									torch.manual_seed(0					)
									lowercase__					:   Tuple													=					UNetaDModel(
									    block_out_channels=(32, 64)				,       layers_per_block=2				,       sample_size=32				,       in_channels=3				,       out_channels=3				,       down_block_types=("DownBlock2D", "AttnDownBlock2D")				,       up_block_types=("AttnUpBlock2D", "UpBlock2D")				,       )
									return model







					@property
					def 			snake_case					(							self :     List[str]					):
									torch.manual_seed(0					)
									lowercase__					:   Optional[int]													=					VQModel(
									    block_out_channels=[32, 64]				,       in_channels=3				,       out_channels=3				,       down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]				,       up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]				,       latent_channels=3				,       )
									return model







					@property
					def 			snake_case					(							self :     Dict					):
									torch.manual_seed(0					)
									lowercase__					:   str													=					CLIPTextConfig(
									    bos_token_id=0				,       eos_token_id=2				,       hidden_size=32				,       intermediate_size=37				,       layer_norm_eps=1E-0_5				,       num_attention_heads=4				,       num_hidden_layers=5				,       pad_token_id=1				,       vocab_size=1_000				,       )
									return CLIPTextModel(SCREAMING_SNAKE_CASE					)







					def 			snake_case					(							self :     str					):
									lowercase__					:   Any													=					self.dummy_uncond_unet
									lowercase__					:   Dict													=					DDIMScheduler()
									lowercase__					:   Optional[Any]													=					self.dummy_vq_model

									lowercase__					:   Union[str, Any]													=					LDMPipeline(unet=SCREAMING_SNAKE_CASE				,       vqvae=SCREAMING_SNAKE_CASE				,       scheduler=SCREAMING_SNAKE_CASE					)
									ldm.to(SCREAMING_SNAKE_CASE					)
									ldm.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE					)

									lowercase__					:   int													=					torch.manual_seed(0					)
									lowercase__					:   Optional[int]													=					ldm(generator=SCREAMING_SNAKE_CASE				,       num_inference_steps=2				,       output_type="numpy"					).images

									lowercase__					:   str													=					torch.manual_seed(0					)
									lowercase__					:   List[Any]													=					ldm(generator=SCREAMING_SNAKE_CASE				,       num_inference_steps=2				,       output_type="numpy"				,       return_dict=SCREAMING_SNAKE_CASE					)[0]

									lowercase__					:   Any													=					image[0, -3:, -3:, -1]
									lowercase__					:   Optional[Any]													=					image_from_tuple[0, -3:, -3:, -1]

									assert image.shape == (1, 64, 64, 3)
									lowercase__					:   List[Any]													=					np.array([0.8_512, 0.818, 0.6_411, 0.6_808, 0.4_465, 0.5_618, 0.46, 0.6_231, 0.5_172]					)
									lowercase__					:   Optional[Any]													=					1E-2 if torch_device != "mps" else 3E-2

									assert np.abs(image_slice.flatten() - expected_slice					).max() < tolerance
									assert np.abs(image_from_tuple_slice.flatten() - expected_slice					).max() < tolerance






@slow
@require_torch
class 				snake_case__(unittest.TestCase      ):

					"""simple docstring"""






					def 			snake_case					(							self :     Optional[Any]					):
									lowercase__					:   int													=					LDMPipeline.from_pretrained("CompVis/ldm-celebahq-256"					)
									ldm.to(SCREAMING_SNAKE_CASE					)
									ldm.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE					)

									lowercase__					:   Dict													=					torch.manual_seed(0					)
									lowercase__					:   Tuple													=					ldm(generator=SCREAMING_SNAKE_CASE				,       num_inference_steps=5				,       output_type="numpy"					).images

									lowercase__					:   Tuple													=					image[0, -3:, -3:, -1]

									assert image.shape == (1, 256, 256, 3)
									lowercase__					:   Optional[Any]													=					np.array([0.4_399, 0.44_975, 0.46_825, 0.474, 0.4_359, 0.4_581, 0.45_095, 0.4_341, 0.4_447]					)
									lowercase__					:   int													=					1E-2 if torch_device != "mps" else 3E-2

									assert np.abs(image_slice.flatten() - expected_slice					).max() < tolerance




