import gc
import unittest

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

from diffusers import TransformeraDModel, VQDiffusionPipeline, VQDiffusionScheduler, VQModel
from diffusers.pipelines.vq_diffusion.pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings
from diffusers.utils import load_numpy, slow, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


__SCREAMING_SNAKE_CASE						:   Optional[int]         =			False



class        lowercase_   (					unittest.TestCase		):



							def 	UpperCamelCase	(						self    ):
													# clean up the VRAM after each test
													super().tearDown()
													gc.collect()
													torch.cuda.empty_cache()



							@property
							def 	UpperCamelCase	(						self    ):
													return 12



							@property
							def 	UpperCamelCase	(						self    ):
													return 12



							@property
							def 	UpperCamelCase	(						self    ):
													return 32



							@property
							def 	UpperCamelCase	(						self    ):
													torch.manual_seed(0    )
													_snake_case						:					Dict    =   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				,    num_vq_embeddings=self.num_embed				,    vq_embed_dim=3				,    )
													return model



							@property
							def 	UpperCamelCase	(						self    ):
													_snake_case						:					List[str]    =   CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"    )
													return tokenizer



							@property
							def 	UpperCamelCase	(						self    ):
													torch.manual_seed(0    )
													_snake_case						:					int    =   CLIPTextConfig(
													    bos_token_id=0				,    eos_token_id=2				,    hidden_size=self.text_embedder_hidden_size				,    intermediate_size=37				,    layer_norm_eps=1e-05				,    num_attention_heads=4				,    num_hidden_layers=5				,    pad_token_id=1				,    vocab_size=1_000				,    )
													return CLIPTextModel(lowercase_    )



							@property
							def 	UpperCamelCase	(						self    ):
													torch.manual_seed(0    )

													_snake_case						:					Dict    =   12
													_snake_case						:					int    =   12

													_snake_case						:					Tuple    =   {
													    "attention_bias": True,
													    "cross_attention_dim": 32,
													    "attention_head_dim": height * width,
													    "num_attention_heads": 1,
													    "num_vector_embeds": self.num_embed,
													    "num_embeds_ada_norm": self.num_embeds_ada_norm,
													    "norm_num_groups": 32,
													    "sample_size": width,
													    "activation_fn": "geglu-approximate",
													}

													_snake_case						:					Optional[Any]    =   TransformeraDModel(**lowercase_    )
													return model



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					Tuple    =   "cpu"

													_snake_case						:					str    =   self.dummy_vqvae
													_snake_case						:					Tuple    =   self.dummy_text_encoder
													_snake_case						:					List[str]    =   self.dummy_tokenizer
													_snake_case						:					List[Any]    =   self.dummy_transformer
													_snake_case						:					Optional[Any]    =   VQDiffusionScheduler(self.num_embed    )
													_snake_case						:					Optional[Any]    =   LearnedClassifierFreeSamplingEmbeddings(learnable=lowercase_    )

													_snake_case						:					int    =   VQDiffusionPipeline(
													    vqvae=lowercase_				,    text_encoder=lowercase_				,    tokenizer=lowercase_				,    transformer=lowercase_				,    scheduler=lowercase_				,    learned_classifier_free_sampling_embeddings=lowercase_				,    )
													_snake_case						:					List[Any]    =   pipe.to(lowercase_    )
													pipe.set_progress_bar_config(disable=lowercase_    )

													_snake_case						:					Optional[int]    =   "teddy bear playing in the pool"

													_snake_case						:					int    =   torch.Generator(device=lowercase_    ).manual_seed(0    )
													_snake_case						:					str    =   pipe([prompt]				,    generator=lowercase_				,    num_inference_steps=2				,    output_type="np"    )
													_snake_case						:					Dict    =   output.images

													_snake_case						:					List[str]    =   torch.Generator(device=lowercase_    ).manual_seed(0    )
													_snake_case						:					Tuple    =   pipe(
													    [prompt]				,    generator=lowercase_				,    output_type="np"				,    return_dict=lowercase_				,    num_inference_steps=2    )[0]

													_snake_case						:					Union[str, Any]    =   image[0, -3:, -3:, -1]
													_snake_case						:					List[str]    =   image_from_tuple[0, -3:, -3:, -1]

													assert image.shape == (1, 24, 24, 3)

													_snake_case						:					Optional[Any]    =   np.array([0.6_551, 0.6_168, 0.5_008, 0.5_676, 0.5_659, 0.4_295, 0.6_073, 0.5_599, 0.4_992]    )

													assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1e-2
													assert np.abs(image_from_tuple_slice.flatten() - expected_slice    ).max() < 1e-2



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					Any    =   "cpu"

													_snake_case						:					str    =   self.dummy_vqvae
													_snake_case						:					List[Any]    =   self.dummy_text_encoder
													_snake_case						:					Union[str, Any]    =   self.dummy_tokenizer
													_snake_case						:					str    =   self.dummy_transformer
													_snake_case						:					int    =   VQDiffusionScheduler(self.num_embed    )
													_snake_case						:					List[str]    =   LearnedClassifierFreeSamplingEmbeddings(
													    learnable=lowercase_				,    hidden_size=self.text_embedder_hidden_size				,    length=tokenizer.model_max_length    )

													_snake_case						:					str    =   VQDiffusionPipeline(
													    vqvae=lowercase_				,    text_encoder=lowercase_				,    tokenizer=lowercase_				,    transformer=lowercase_				,    scheduler=lowercase_				,    learned_classifier_free_sampling_embeddings=lowercase_				,    )
													_snake_case						:					Union[str, Any]    =   pipe.to(lowercase_    )
													pipe.set_progress_bar_config(disable=lowercase_    )

													_snake_case						:					Any    =   "teddy bear playing in the pool"

													_snake_case						:					Dict    =   torch.Generator(device=lowercase_    ).manual_seed(0    )
													_snake_case						:					List[Any]    =   pipe([prompt]				,    generator=lowercase_				,    num_inference_steps=2				,    output_type="np"    )
													_snake_case						:					Dict    =   output.images

													_snake_case						:					int    =   torch.Generator(device=lowercase_    ).manual_seed(0    )
													_snake_case						:					Dict    =   pipe(
													    [prompt]				,    generator=lowercase_				,    output_type="np"				,    return_dict=lowercase_				,    num_inference_steps=2    )[0]

													_snake_case						:					Dict    =   image[0, -3:, -3:, -1]
													_snake_case						:					Any    =   image_from_tuple[0, -3:, -3:, -1]

													assert image.shape == (1, 24, 24, 3)

													_snake_case						:					str    =   np.array([0.6_693, 0.6_075, 0.4_959, 0.5_701, 0.5_583, 0.4_333, 0.6_171, 0.5_684, 0.4_988]    )

													assert np.abs(image_slice.flatten() - expected_slice    ).max() < 2.0
													assert np.abs(image_from_tuple_slice.flatten() - expected_slice    ).max() < 1e-2




@slow
@require_torch_gpu
class        lowercase_   (					unittest.TestCase		):



							def 	UpperCamelCase	(						self    ):
													# clean up the VRAM after each test
													super().tearDown()
													gc.collect()
													torch.cuda.empty_cache()



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					Any    =   load_numpy(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
													    "/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy"    )

													_snake_case						:					List[Any]    =   VQDiffusionPipeline.from_pretrained("microsoft/vq-diffusion-ithq"    )
													_snake_case						:					int    =   pipeline.to(lowercase_    )
													pipeline.set_progress_bar_config(disable=lowercase_    )

													# requires GPU generator for gumbel softmax
													# don't use GPU generator in tests though
													_snake_case						:					Optional[Any]    =   torch.Generator(device=lowercase_    ).manual_seed(0    )
													_snake_case						:					List[Any]    =   pipeline(
													    "teddy bear playing in the pool"				,    num_images_per_prompt=1				,    generator=lowercase_				,    output_type="np"				,    )

													_snake_case						:					Union[str, Any]    =   output.images[0]

													assert image.shape == (256, 256, 3)
													assert np.abs(expected_image - image    ).max() < 2.0
import shutil
import tempfile
import unittest

from transformers import ClapFeatureExtractor, ClapProcessor, RobertaTokenizer, RobertaTokenizerFast
from transformers.testing_utils import require_sentencepiece, require_torchaudio

from .test_feature_extraction_clap import floats_list



@require_torchaudio
@require_sentencepiece
class        lowercase_   (					unittest.TestCase		):



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					str    =   "laion/clap-htsat-unfused"
													_snake_case						:					Dict    =   tempfile.mkdtemp()



							def 	UpperCamelCase	(						self				,    **lowercase_    ):
													return RobertaTokenizer.from_pretrained(self.checkpoint				,    **lowercase_    )



							def 	UpperCamelCase	(						self				,    **lowercase_    ):
													return ClapFeatureExtractor.from_pretrained(self.checkpoint				,    **lowercase_    )



							def 	UpperCamelCase	(						self    ):
													shutil.rmtree(self.tmpdirname    )



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					Optional[int]    =   self.get_tokenizer()
													_snake_case						:					List[Any]    =   self.get_feature_extractor()

													_snake_case						:					Optional[Any]    =   ClapProcessor(tokenizer=lowercase_				,    feature_extractor=lowercase_    )

													processor.save_pretrained(self.tmpdirname    )
													_snake_case						:					Tuple    =   ClapProcessor.from_pretrained(self.tmpdirname    )

													self.assertEqual(processor.tokenizer.get_vocab()				,    tokenizer.get_vocab()    )
													self.assertIsInstance(processor.tokenizer				,    lowercase_    )

													self.assertEqual(processor.feature_extractor.to_json_string()				,    feature_extractor.to_json_string()    )
													self.assertIsInstance(processor.feature_extractor				,    lowercase_    )



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					Any    =   ClapProcessor(tokenizer=self.get_tokenizer()				,    feature_extractor=self.get_feature_extractor()    )
													processor.save_pretrained(self.tmpdirname    )

													_snake_case						:					Any    =   self.get_tokenizer(bos_token="(BOS)"				,    eos_token="(EOS)"    )
													_snake_case						:					List[Any]    =   self.get_feature_extractor(do_normalize=lowercase_				,    padding_value=1.0    )

													_snake_case						:					List[Any]    =   ClapProcessor.from_pretrained(
													    self.tmpdirname				,    bos_token="(BOS)"				,    eos_token="(EOS)"				,    do_normalize=lowercase_				,    padding_value=1.0    )

													self.assertEqual(processor.tokenizer.get_vocab()				,    tokenizer_add_kwargs.get_vocab()    )
													self.assertIsInstance(processor.tokenizer				,    lowercase_    )

													self.assertEqual(processor.feature_extractor.to_json_string()				,    feature_extractor_add_kwargs.to_json_string()    )
													self.assertIsInstance(processor.feature_extractor				,    lowercase_    )



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					Tuple    =   self.get_feature_extractor()
													_snake_case						:					Union[str, Any]    =   self.get_tokenizer()

													_snake_case						:					Optional[Any]    =   ClapProcessor(tokenizer=lowercase_				,    feature_extractor=lowercase_    )

													_snake_case						:					List[str]    =   floats_list((3, 1_000)    )

													_snake_case						:					Union[str, Any]    =   feature_extractor(lowercase_				,    return_tensors="np"    )
													_snake_case						:					Any    =   processor(audios=lowercase_				,    return_tensors="np"    )

													for key in input_feat_extract.keys():
																			self.assertAlmostEqual(input_feat_extract[key].sum()				,    input_processor[key].sum()				,    delta=1e-2    )



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					str    =   self.get_feature_extractor()
													_snake_case						:					Optional[Any]    =   self.get_tokenizer()

													_snake_case						:					Dict    =   ClapProcessor(tokenizer=lowercase_				,    feature_extractor=lowercase_    )

													_snake_case						:					Any    =   "This is a test string"

													_snake_case						:					Optional[Any]    =   processor(text=lowercase_    )

													_snake_case						:					Optional[Any]    =   tokenizer(lowercase_    )

													for key in encoded_tok.keys():
																			self.assertListEqual(encoded_tok[key]				,    encoded_processor[key]    )



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					Dict    =   self.get_feature_extractor()
													_snake_case						:					Dict    =   self.get_tokenizer()

													_snake_case						:					List[Any]    =   ClapProcessor(tokenizer=lowercase_				,    feature_extractor=lowercase_    )

													_snake_case						:					Dict    =   [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

													_snake_case						:					List[Any]    =   processor.batch_decode(lowercase_    )
													_snake_case						:					Optional[int]    =   tokenizer.batch_decode(lowercase_    )

													self.assertListEqual(lowercase_				,    lowercase_    )



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					List[str]    =   self.get_feature_extractor()
													_snake_case						:					str    =   self.get_tokenizer()

													_snake_case						:					Optional[int]    =   ClapProcessor(tokenizer=lowercase_				,    feature_extractor=lowercase_    )

													self.assertListEqual(
													    processor.model_input_names[2:]				,    feature_extractor.model_input_names				,    msg="`processor` and `feature_extractor` model input names do not match"				,    )