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


__lowercase							 =					False


class 	lowerCamelCase_     (   unittest.TestCase ):






    '''simple docstring'''






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







    @property
    def 			UpperCamelCase__   (	self)       ->	Optional[Any]:
        return 12







    @property
    def 			UpperCamelCase__   (	self)       ->	int:
        return 12







    @property
    def 			UpperCamelCase__   (	self)       ->	Union[str, Any]:
        return 32







    @property
    def 			UpperCamelCase__   (	self)       ->	Dict:
        torch.manual_seed(0)
        __UpperCamelCase     :List[str]			  =		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)       ->	int:
        __UpperCamelCase     :Dict			  =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')
        return tokenizer







    @property
    def 			UpperCamelCase__   (	self)       ->	Dict:
        torch.manual_seed(0)
        __UpperCamelCase     :Optional[Any]			  =		CLIPTextConfig(
            bos_token_id=0 , eos_token_id=2 , hidden_size=self.text_embedder_hidden_size , 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(__lowercase)







    @property
    def 			UpperCamelCase__   (	self)       ->	List[Any]:
        torch.manual_seed(0)

        __UpperCamelCase     :List[str]			  =		12
        __UpperCamelCase     :str			  =		12

        __UpperCamelCase     :Optional[int]			  =		{
            '''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''',
        }

        __UpperCamelCase     :int			  =		TransformeraDModel(**__lowercase)
        return model







    def 			UpperCamelCase__   (	self)       ->	Union[str, Any]:
        __UpperCamelCase     :List[str]			  =		'''cpu'''

        __UpperCamelCase     :Optional[Any]			  =		self.dummy_vqvae
        __UpperCamelCase     :Tuple			  =		self.dummy_text_encoder
        __UpperCamelCase     :Any			  =		self.dummy_tokenizer
        __UpperCamelCase     :Any			  =		self.dummy_transformer
        __UpperCamelCase     :int			  =		VQDiffusionScheduler(self.num_embed)
        __UpperCamelCase     :Union[str, Any]			  =		LearnedClassifierFreeSamplingEmbeddings(learnable=__lowercase)

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

        __UpperCamelCase     :Any			  =		'''teddy bear playing in the pool'''

        __UpperCamelCase     :Tuple			  =		torch.Generator(device=__lowercase).manual_seed(0)
        __UpperCamelCase     :Any			  =		pipe([prompt] , generator=__lowercase , num_inference_steps=2 , output_type='''np''')
        __UpperCamelCase     :str			  =		output.images

        __UpperCamelCase     :int			  =		torch.Generator(device=__lowercase).manual_seed(0)
        __UpperCamelCase     :Union[str, Any]			  =		pipe(
            [prompt] , generator=__lowercase , output_type='''np''' , return_dict=__lowercase , num_inference_steps=2)[0]

        __UpperCamelCase     :Dict			  =		image[0, -3:, -3:, -1]
        __UpperCamelCase     :int			  =		image_from_tuple[0, -3:, -3:, -1]

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

        __UpperCamelCase     :str			  =		np.array([0.65_51, 0.61_68, 0.50_08, 0.56_76, 0.56_59, 0.42_95, 0.60_73, 0.55_99, 0.49_92])

        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)       ->	Tuple:
        __UpperCamelCase     :int			  =		'''cpu'''

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

        __UpperCamelCase     :List[str]			  =		VQDiffusionPipeline(
            vqvae=__lowercase , text_encoder=__lowercase , tokenizer=__lowercase , transformer=__lowercase , scheduler=__lowercase , learned_classifier_free_sampling_embeddings=__lowercase , )
        __UpperCamelCase     :Optional[int]			  =		pipe.to(__lowercase)
        pipe.set_progress_bar_config(disable=__lowercase)

        __UpperCamelCase     :Optional[Any]			  =		'''teddy bear playing in the pool'''

        __UpperCamelCase     :Any			  =		torch.Generator(device=__lowercase).manual_seed(0)
        __UpperCamelCase     :str			  =		pipe([prompt] , generator=__lowercase , num_inference_steps=2 , output_type='''np''')
        __UpperCamelCase     :Union[str, Any]			  =		output.images

        __UpperCamelCase     :Any			  =		torch.Generator(device=__lowercase).manual_seed(0)
        __UpperCamelCase     :Tuple			  =		pipe(
            [prompt] , generator=__lowercase , output_type='''np''' , return_dict=__lowercase , num_inference_steps=2)[0]

        __UpperCamelCase     :str			  =		image[0, -3:, -3:, -1]
        __UpperCamelCase     :Dict			  =		image_from_tuple[0, -3:, -3:, -1]

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

        __UpperCamelCase     :Optional[int]			  =		np.array([0.66_93, 0.60_75, 0.49_59, 0.57_01, 0.55_83, 0.43_33, 0.61_71, 0.56_84, 0.49_88])

        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 	lowerCamelCase_     (   unittest.TestCase ):






    '''simple docstring'''






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







    def 			UpperCamelCase__   (	self)       ->	Optional[Any]:
        __UpperCamelCase     :Optional[Any]			  =		load_numpy(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
            '''/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy''')

        __UpperCamelCase     :List[Any]			  =		VQDiffusionPipeline.from_pretrained('''microsoft/vq-diffusion-ithq''')
        __UpperCamelCase     :str			  =		pipeline.to(__lowercase)
        pipeline.set_progress_bar_config(disable=__lowercase)

        # requires GPU generator for gumbel softmax
        # don't use GPU generator in tests though
        __UpperCamelCase     :Union[str, Any]			  =		torch.Generator(device=__lowercase).manual_seed(0)
        __UpperCamelCase     :Tuple			  =		pipeline(
            '''teddy bear playing in the pool''' , num_images_per_prompt=1 , generator=__lowercase , output_type='''np''' , )

        __UpperCamelCase     :Optional[int]			  =		output.images[0]

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






def lowerCamelCase  (   SCREAMING_SNAKE_CASE = 1  ,			SCREAMING_SNAKE_CASE = 1_000	):
    '''simple docstring'''







    __UpperCamelCase     :Union[str, Any]			  =		1
    __UpperCamelCase     :Any			  =		0

    for divide_by_number in range(SCREAMING_SNAKE_CASE  ,			digit + 1	):
        __UpperCamelCase     :list[int]			  =		[]
        __UpperCamelCase     :Optional[int]			  =		numerator
        for _ in range(1  ,			digit + 1	):
            if now_divide in has_been_divided:
                if longest_list_length < len(SCREAMING_SNAKE_CASE	):
                    __UpperCamelCase     :Optional[Any]			  =		len(SCREAMING_SNAKE_CASE	)
                    __UpperCamelCase     :int			  =		divide_by_number
            else:
                has_been_divided.append(SCREAMING_SNAKE_CASE	)
                __UpperCamelCase     :Any			  =		now_divide * 10 % divide_by_number

    return the_digit


# Tests
if __name__ == "__main__":
    import doctest

    doctest.testmod()





