





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        __SCREAMING_SNAKE_CASE      (			lowerCAmelCase_					,unittest.TestCase ):
       _UpperCAmelCase				:  List[str]			   =   LDMTextToImagePipeline
       _UpperCAmelCase				:  Union[str, Any]			   =   TEXT_TO_IMAGE_PARAMS - {
           "negative_prompt",
           "negative_prompt_embeds",
           "cross_attention_kwargs",
           "prompt_embeds",
       }
       _UpperCAmelCase				:  Optional[Any]			   =   PipelineTesterMixin.required_optional_params - {
           "num_images_per_prompt",
           "callback",
           "callback_steps",
       }
       _UpperCAmelCase				:  List[str]			   =   TEXT_TO_IMAGE_BATCH_PARAMS
       _UpperCAmelCase				:  Tuple			   =   False







       def 						__lowerCamelCase   (				self					:     Optional[int]      )       ->Tuple:
          torch.manual_seed(0      )
          lowerCamelCase__       :						Optional[int]        =							UNetaDConditionModel(
              block_out_channels=(3_2, 6_4)		, layers_per_block=2		, sample_size=3_2		, in_channels=4		, out_channels=4		, down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')		, up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')		, cross_attention_dim=3_2		, )
          lowerCamelCase__       :						Any        =							DDIMScheduler(
              beta_start=0.0_00_85		, beta_end=0.0_12		, beta_schedule='''scaled_linear'''		, clip_sample=A		, set_alpha_to_one=A		, )
          torch.manual_seed(0      )
          lowerCamelCase__       :						int        =							AutoencoderKL(
              block_out_channels=(3_2, 6_4)		, in_channels=3		, out_channels=3		, down_block_types=('''DownEncoderBlock2D''', '''DownEncoderBlock2D''')		, up_block_types=('''UpDecoderBlock2D''', '''UpDecoderBlock2D''')		, latent_channels=4		, )
          torch.manual_seed(0      )
          lowerCamelCase__       :						Tuple        =							CLIPTextConfig(
              bos_token_id=0		, eos_token_id=2		, hidden_size=3_2		, intermediate_size=3_7		, layer_norm_eps=1e-05		, num_attention_heads=4		, num_hidden_layers=5		, pad_token_id=1		, vocab_size=1_0_0_0		, )
          lowerCamelCase__       :						Any        =							CLIPTextModel(A      )
          lowerCamelCase__       :						int        =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

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







       def 						__lowerCamelCase   (				self					:     Optional[int]		, A					:     Dict		, A					:     List[str]=0      )       ->Any:
          if str(A      ).startswith('''mps'''      ):
             lowerCamelCase__       :						List[Any]        =							torch.manual_seed(A      )
          else:
             lowerCamelCase__       :						Any        =							torch.Generator(device=A      ).manual_seed(A      )
          lowerCamelCase__       :						Tuple        =							{
              '''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 						__lowerCamelCase   (				self					:     int      )       ->Tuple:
          lowerCamelCase__       :						Optional[Any]        =							'''cpu'''  # ensure determinism for the device-dependent torch.Generator

          lowerCamelCase__       :						Union[str, Any]        =							self.get_dummy_components()
          lowerCamelCase__       :						Dict        =							LDMTextToImagePipeline(**A      )
          pipe.to(A      )
          pipe.set_progress_bar_config(disable=A      )

          lowerCamelCase__       :						Optional[Any]        =							self.get_dummy_inputs(A      )
          lowerCamelCase__       :						List[str]        =							pipe(**A      ).images
          lowerCamelCase__       :						Optional[int]        =							image[0, -3:, -3:, -1]

          assert image.shape == (1, 1_6, 1_6, 3)
          lowerCamelCase__       :						Tuple        =							np.array([0.61_01, 0.61_56, 0.56_22, 0.48_95, 0.66_61, 0.38_04, 0.57_48, 0.61_36, 0.50_14]      )

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


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







       def 						__lowerCamelCase   (				self					:     str      )       ->Optional[Any]:
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()







       def 						__lowerCamelCase   (				self					:     Dict		, A					:     Any		, A					:     int=torch.floataa		, A					:     Dict=0      )       ->Dict:
          lowerCamelCase__       :						Optional[int]        =							torch.manual_seed(A      )
          lowerCamelCase__       :						Optional[int]        =							np.random.RandomState(A      ).standard_normal((1, 4, 3_2, 3_2)      )
          lowerCamelCase__       :						List[Any]        =							torch.from_numpy(A      ).to(device=A		, dtype=A      )
          lowerCamelCase__       :						Optional[Any]        =							{
              '''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 						__lowerCamelCase   (				self					:     Optional[int]      )       ->str:
          lowerCamelCase__       :						Any        =							LDMTextToImagePipeline.from_pretrained('''CompVis/ldm-text2im-large-256'''      ).to(A      )
          pipe.set_progress_bar_config(disable=A      )

          lowerCamelCase__       :						Tuple        =							self.get_inputs(A      )
          lowerCamelCase__       :						Dict        =							pipe(**A      ).images
          lowerCamelCase__       :						Union[str, Any]        =							image[0, -3:, -3:, -1].flatten()

          assert image.shape == (1, 2_5_6, 2_5_6, 3)
          lowerCamelCase__       :						List[Any]        =							np.array([0.5_18_25, 0.5_28_50, 0.5_25_43, 0.5_42_58, 0.5_23_04, 0.5_25_69, 0.5_43_63, 0.5_52_76, 0.5_68_78]      )
          lowerCamelCase__       :						int        =							np.abs(expected_slice - image_slice      ).max()
          assert max_diff < 1e-3


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







       def 						__lowerCamelCase   (				self					:     Tuple      )       ->Tuple:
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()







       def 						__lowerCamelCase   (				self					:     Dict		, A					:     Optional[int]		, A					:     int=torch.floataa		, A					:     Tuple=0      )       ->int:
          lowerCamelCase__       :						List[Any]        =							torch.manual_seed(A      )
          lowerCamelCase__       :						Optional[Any]        =							np.random.RandomState(A      ).standard_normal((1, 4, 3_2, 3_2)      )
          lowerCamelCase__       :						Any        =							torch.from_numpy(A      ).to(device=A		, dtype=A      )
          lowerCamelCase__       :						Dict        =							{
              '''prompt''': '''A painting of a squirrel eating a burger''',
              '''latents''': latents,
              '''generator''': generator,
              '''num_inference_steps''': 5_0,
              '''guidance_scale''': 6.0,
              '''output_type''': '''numpy''',
          }
          return inputs







       def 						__lowerCamelCase   (				self					:     Optional[int]      )       ->Tuple:
          lowerCamelCase__       :						Optional[int]        =							LDMTextToImagePipeline.from_pretrained('''CompVis/ldm-text2im-large-256'''      ).to(A      )
          pipe.set_progress_bar_config(disable=A      )

          lowerCamelCase__       :						Tuple        =							self.get_inputs(A      )
          lowerCamelCase__       :						Optional[Any]        =							pipe(**A      ).images[0]

          lowerCamelCase__       :						Any        =							load_numpy(
              '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/ldm_text2img/ldm_large_256_ddim.npy'''      )
          lowerCamelCase__       :						Tuple        =							np.abs(expected_image - image      ).max()
          assert max_diff < 1e-3










def 	_a						(   UpperCAmelCase					)    ->    int:







   """simple docstring"""

   if not isinstance(UpperCAmelCase      ,  UpperCAmelCase					):
      raise TypeError('''only integers accepted as input'''					)
   else:
      lowerCamelCase__       :						Any        =							str(abs(UpperCAmelCase					)					)
      lowerCamelCase__       :						Union[str, Any]        =							[list(UpperCAmelCase					) for char in range(len(UpperCAmelCase					)					)]
      for index in range(len(UpperCAmelCase					)					):
         num_transpositions[index].pop(UpperCAmelCase					)
      return max(
          int(''''''.join(list(UpperCAmelCase					)					)					) for transposition in num_transpositions					)


if __name__ == "__main__":
       __import__('doctest').testmod()



