

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       __snake_case  (    lowercase_     , unittest.TestCase       ):
  __lowerCAmelCase     :	Any						 =  LDMTextToImagePipeline
  __lowerCAmelCase     :	int						 =  TEXT_TO_IMAGE_PARAMS - {
      '''negative_prompt''',
      '''negative_prompt_embeds''',
      '''cross_attention_kwargs''',
      '''prompt_embeds''',
  }
  __lowerCAmelCase     :	int						 =  PipelineTesterMixin.required_optional_params - {
      '''num_images_per_prompt''',
      '''callback''',
      '''callback_steps''',
  }
  __lowerCAmelCase     :	Optional[int]						 =  TEXT_TO_IMAGE_BATCH_PARAMS
  __lowerCAmelCase     :	Any						 =  False

  def 						lowerCAmelCase__     (					self):
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_									=						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						,		)
      SCREAMING_SNAKE_CASE_									=						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)
      SCREAMING_SNAKE_CASE_									=						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)
      SCREAMING_SNAKE_CASE_									=						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						,		)
      SCREAMING_SNAKE_CASE_									=						CLIPTextModel(UpperCamelCase__)
      SCREAMING_SNAKE_CASE_									=						CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

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

  def 						lowerCAmelCase__     (					self						,		_A						,		_A=0):







      if str(UpperCamelCase__).startswith('mps'):
          SCREAMING_SNAKE_CASE_									=						torch.manual_seed(UpperCamelCase__)
      else:
          SCREAMING_SNAKE_CASE_									=						torch.Generator(device=UpperCamelCase__).manual_seed(UpperCamelCase__)
      SCREAMING_SNAKE_CASE_									=						{
          '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):
      SCREAMING_SNAKE_CASE_									=						'cpu'  # ensure determinism for the device-dependent torch.Generator

      SCREAMING_SNAKE_CASE_									=						self.get_dummy_components()
      SCREAMING_SNAKE_CASE_									=						LDMTextToImagePipeline(**UpperCamelCase__)
      pipe.to(UpperCamelCase__)
      pipe.set_progress_bar_config(disable=UpperCamelCase__)

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

      assert image.shape == (1, 16, 16, 3)
      SCREAMING_SNAKE_CASE_									=						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       __snake_case  (    unittest.TestCase       ):

  def 						lowerCAmelCase__     (					self):
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()

  def 						lowerCAmelCase__     (					self						,		_A						,		_A=torch.floataa						,		_A=0):
      SCREAMING_SNAKE_CASE_									=						torch.manual_seed(UpperCamelCase__)
      SCREAMING_SNAKE_CASE_									=						np.random.RandomState(UpperCamelCase__).standard_normal((1, 4, 32, 32))
      SCREAMING_SNAKE_CASE_									=						torch.from_numpy(UpperCamelCase__).to(device=UpperCamelCase__						,		dtype=UpperCamelCase__)
      SCREAMING_SNAKE_CASE_									=						{
          '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):
      SCREAMING_SNAKE_CASE_									=						LDMTextToImagePipeline.from_pretrained('CompVis/ldm-text2im-large-256').to(UpperCamelCase__)
      pipe.set_progress_bar_config(disable=UpperCamelCase__)

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

      assert image.shape == (1, 256, 256, 3)
      SCREAMING_SNAKE_CASE_									=						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])
      SCREAMING_SNAKE_CASE_									=						np.abs(expected_slice - image_slice).max()
      assert max_diff < 1E-3






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

  def 						lowerCAmelCase__     (					self):
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()

  def 						lowerCAmelCase__     (					self						,		_A						,		_A=torch.floataa						,		_A=0):
      SCREAMING_SNAKE_CASE_									=						torch.manual_seed(UpperCamelCase__)
      SCREAMING_SNAKE_CASE_									=						np.random.RandomState(UpperCamelCase__).standard_normal((1, 4, 32, 32))
      SCREAMING_SNAKE_CASE_									=						torch.from_numpy(UpperCamelCase__).to(device=UpperCamelCase__						,		dtype=UpperCamelCase__)
      SCREAMING_SNAKE_CASE_									=						{
          '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 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						LDMTextToImagePipeline.from_pretrained('CompVis/ldm-text2im-large-256').to(UpperCamelCase__)
      pipe.set_progress_bar_config(disable=UpperCamelCase__)

      SCREAMING_SNAKE_CASE_									=						self.get_inputs(UpperCamelCase__)
      SCREAMING_SNAKE_CASE_									=						pipe(**UpperCamelCase__).images[0]

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





def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		int = 200       ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						[1, 2, 5, 10, 20, 50, 100, 200]
    SCREAMING_SNAKE_CASE_									=						[0] * (pence + 1)
    SCREAMING_SNAKE_CASE_									=						1  # base case: 1 way to make 0 pence

    for coin in coins:
        for i in range(_SCREAMING_SNAKE_CASE ,   pence + 1 ,   1       ):
            number_of_ways[i] += number_of_ways[i - coin]
    return number_of_ways[pence]


if __name__ == "__main__":
       assert solution(200) == 73_682


