


import gc
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, LDMTextToImagePipeline, UNetaDConditionModel
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    load_numpy,
    nightly,
    require_torch_gpu,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()



class 		_lowercase		(       lowercase__,   unittest.TestCase	):
   _UpperCAmelCase     	=			LDMTextToImagePipeline
   _UpperCAmelCase     	=			TEXT_TO_IMAGE_PARAMS - {
       '''negative_prompt''',
       '''negative_prompt_embeds''',
       '''cross_attention_kwargs''',
       '''prompt_embeds''',
   }
   _UpperCAmelCase     	=			PipelineTesterMixin.required_optional_params - {
       '''num_images_per_prompt''',
       '''callback''',
       '''callback_steps''',
   }
   _UpperCAmelCase     	=			TEXT_TO_IMAGE_BATCH_PARAMS
   _UpperCAmelCase     	=			False

   def 		A							(      self			:       Optional[Any]							)       ->				Tuple:


    """simple docstring"""






    torch.manual_seed(0							)
    a						=		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							,   )
    a						=		DDIMScheduler(
        beta_start=0.0_0_0_8_5							,   beta_end=0.0_1_2							,   beta_schedule="scaled_linear"							,   clip_sample=UpperCAmelCase__							,   set_alpha_to_one=UpperCAmelCase__							,   )
    torch.manual_seed(0							)
    a						=		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							,   )
    torch.manual_seed(0							)
    a						=		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=1000							,   )
    a						=		CLIPTextModel(UpperCAmelCase__							)
    a						=		CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"							)

    a						=		{
        '''unet''': unet,
        '''scheduler''': scheduler,
        '''vqvae''': vae,
        '''bert''': text_encoder,
        '''tokenizer''': tokenizer,
    }
    return components

   def 		A							(      self			:       Optional[int]							,   __lowerCAmelCase			:       Optional[int]							,   __lowerCAmelCase			:       List[Any]=0							)       ->				List[Any]:


    """simple docstring"""






    if str(UpperCAmelCase__							).startswith("mps"							):
     a						=		torch.manual_seed(UpperCAmelCase__							)
    else:
     a						=		torch.Generator(device=UpperCAmelCase__							).manual_seed(UpperCAmelCase__							)
    a						=		{
        '''prompt''': '''A painting of a squirrel eating a burger''',
        '''generator''': generator,
        '''num_inference_steps''': 2,
        '''guidance_scale''': 6.0,
        '''output_type''': '''numpy''',
    }
    return inputs




   def 		A							(      self			:       str							)       ->				Optional[Any]:


    """simple docstring"""






    a						=		'''cpu'''  # ensure determinism for the device-dependent torch.Generator

    a						=		self.get_dummy_components()
    a						=		LDMTextToImagePipeline(**UpperCAmelCase__							)
    pipe.to(UpperCAmelCase__							)
    pipe.set_progress_bar_config(disable=UpperCAmelCase__							)

    a						=		self.get_dummy_inputs(UpperCAmelCase__							)
    a						=		pipe(**UpperCAmelCase__							).images
    a						=		image[0, -3:, -3:, -1]

    assert image.shape == (1, 16, 16, 3)
    a						=		np.array([0.6_1_0_1, 0.6_1_5_6, 0.5_6_2_2, 0.4_8_9_5, 0.6_6_6_1, 0.3_8_0_4, 0.5_7_4_8, 0.6_1_3_6, 0.5_0_1_4]							)

    assert np.abs(image_slice.flatten() - expected_slice							).max() < 1E-3



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

   def 		A							(      self			:       Any							)       ->				int:


    """simple docstring"""






    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()

   def 		A							(      self			:       int							,   __lowerCAmelCase			:       Dict							,   __lowerCAmelCase			:       Dict=torch.floataa							,   __lowerCAmelCase			:       str=0							)       ->				Any:


    """simple docstring"""






    a						=		torch.manual_seed(UpperCAmelCase__							)
    a						=		np.random.RandomState(UpperCAmelCase__							).standard_normal((1, 4, 32, 32)							)
    a						=		torch.from_numpy(UpperCAmelCase__							).to(device=UpperCAmelCase__							,   dtype=UpperCAmelCase__							)
    a						=		{
        '''prompt''': '''A painting of a squirrel eating a burger''',
        '''latents''': latents,
        '''generator''': generator,
        '''num_inference_steps''': 3,
        '''guidance_scale''': 6.0,
        '''output_type''': '''numpy''',
    }
    return inputs




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


    """simple docstring"""






    a						=		LDMTextToImagePipeline.from_pretrained("CompVis/ldm-text2im-large-256"							).to(UpperCAmelCase__							)
    pipe.set_progress_bar_config(disable=UpperCAmelCase__							)

    a						=		self.get_inputs(UpperCAmelCase__							)
    a						=		pipe(**UpperCAmelCase__							).images
    a						=		image[0, -3:, -3:, -1].flatten()

    assert image.shape == (1, 256, 256, 3)
    a						=		np.array([0.5_1_8_2_5, 0.5_2_8_5_0, 0.5_2_5_4_3, 0.5_4_2_5_8, 0.5_2_3_0_4, 0.5_2_5_6_9, 0.5_4_3_6_3, 0.5_5_2_7_6, 0.5_6_8_7_8]							)
    a						=		np.abs(expected_slice - image_slice							).max()
    assert max_diff < 1E-3



@nightly
@require_torch_gpu
class 		_lowercase		(       unittest.TestCase	):

   def 		A							(      self			:       int							)       ->				Optional[int]:


    """simple docstring"""






    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()

   def 		A							(      self			:       str							,   __lowerCAmelCase			:       Tuple							,   __lowerCAmelCase			:       Optional[int]=torch.floataa							,   __lowerCAmelCase			:       Any=0							)       ->				int:


    """simple docstring"""






    a						=		torch.manual_seed(UpperCAmelCase__							)
    a						=		np.random.RandomState(UpperCAmelCase__							).standard_normal((1, 4, 32, 32)							)
    a						=		torch.from_numpy(UpperCAmelCase__							).to(device=UpperCAmelCase__							,   dtype=UpperCAmelCase__							)
    a						=		{
        '''prompt''': '''A painting of a squirrel eating a burger''',
        '''latents''': latents,
        '''generator''': generator,
        '''num_inference_steps''': 50,
        '''guidance_scale''': 6.0,
        '''output_type''': '''numpy''',
    }
    return inputs




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


    """simple docstring"""






    a						=		LDMTextToImagePipeline.from_pretrained("CompVis/ldm-text2im-large-256"							).to(UpperCAmelCase__							)
    pipe.set_progress_bar_config(disable=UpperCAmelCase__							)

    a						=		self.get_inputs(UpperCAmelCase__							)
    a						=		pipe(**UpperCAmelCase__							).images[0]

    a						=		load_numpy(
        "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/ldm_text2img/ldm_large_256_ddim.npy"							)
    a						=		np.abs(expected_image - image							).max()
    assert max_diff < 1E-3






from __future__ import annotations


def 	UpperCAmelCase__      (      UpperCAmelCase__ :int					):






 '''simple docstring'''

 a						=		str(UpperCAmelCase__					)
 return len(UpperCAmelCase__					) == 9 and set(UpperCAmelCase__					) == set("123456789"					)


def 	UpperCAmelCase__      (      ):






 '''simple docstring'''

 for base_num in range(99_99 ,					49_99 ,					-1					):
  a						=		10_00_02 * base_num
  if is_9_pandigital(UpperCAmelCase__					):
   return candidate

 for base_num in range(3_33 ,					99 ,					-1					):
  a						=		1_00_20_03 * base_num
  if is_9_pandigital(UpperCAmelCase__					):
   return candidate

 return None


if __name__ == "__main__":
     print(F"""{solution() = }""")

