






'''simple docstring'''
import gc
import unittest

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

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

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


enable_full_determinism()




class        _UpperCAmelCase						(		snake_case				,					snake_case				,					unittest.TestCase			):
    __lowerCamelCase:   List[Any]		       =    StableDiffusionSAGPipeline
    __lowerCamelCase:   str		       =    TEXT_TO_IMAGE_PARAMS
    __lowerCamelCase:   Dict		       =    TEXT_TO_IMAGE_BATCH_PARAMS
    __lowerCamelCase:   str		       =    TEXT_TO_IMAGE_IMAGE_PARAMS
    __lowerCamelCase:   Optional[int]		       =    TEXT_TO_IMAGE_IMAGE_PARAMS
    __lowerCamelCase:   Union[str, Any]		       =    False




    def 				lowerCAmelCase__				(			self  :       List[str]			):






       '''simple docstring'''






       torch.manual_seed(0			)
       lowercase_	:    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  ,     )
       lowercase_	:    int           =     DDIMScheduler(
           beta_start=0.0_0085  ,     beta_end=0.012  ,     beta_schedule="scaled_linear"  ,     clip_sample=a  ,     set_alpha_to_one=a  ,     )
       torch.manual_seed(0			)
       lowercase_	:    str           =     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			)
       lowercase_	:    List[str]           =     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  ,     )
       lowercase_	:    Union[str, Any]           =     CLIPTextModel(a			)
       lowercase_	:    List[Any]           =     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"			)

       lowercase_	:    str           =     {
           "unet": unet,
           "scheduler": scheduler,
           "vae": vae,
           "text_encoder": text_encoder,
           "tokenizer": tokenizer,
           "safety_checker": None,
           "feature_extractor": None,
       }
       return components




    def 				lowerCAmelCase__				(			self  :       Tuple  ,     a  :       Optional[int]  ,     a  :       Any=0			):






       '''simple docstring'''






       if str(a			).startswith("mps"			):
          lowercase_	:    int           =     torch.manual_seed(a			)
       else:
          lowercase_	:    str           =     torch.Generator(device=a			).manual_seed(a			)
       lowercase_	:    Dict           =     {
           "prompt": ".",
           "generator": generator,
           "num_inference_steps": 2,
           "guidance_scale": 1.0,
           "sag_scale": 1.0,
           "output_type": "numpy",
       }
       return inputs





    def 				lowerCAmelCase__				(			self  :       Any			):






       '''simple docstring'''






       super().test_inference_batch_single_identical(expected_max_diff=3e-3			)




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




    def 				lowerCAmelCase__				(			self  :       str			):






       '''simple docstring'''






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




    def 				lowerCAmelCase__				(			self  :       Tuple			):






       '''simple docstring'''






       lowercase_	:    Union[str, Any]           =     StableDiffusionSAGPipeline.from_pretrained("CompVis/stable-diffusion-v1-4"			)
       lowercase_	:    Union[str, Any]           =     sag_pipe.to(a			)
       sag_pipe.set_progress_bar_config(disable=a			)

       lowercase_	:    Optional[int]           =     "."
       lowercase_	:    Union[str, Any]           =     torch.manual_seed(0			)
       lowercase_	:    Optional[Any]           =     sag_pipe(
           [prompt]  ,     generator=a  ,     guidance_scale=7.5  ,     sag_scale=1.0  ,     num_inference_steps=2_0  ,     output_type="np"			)

       lowercase_	:    str           =     output.images

       lowercase_	:    Tuple           =     image[0, -3:, -3:, -1]

       assert image.shape == (1, 5_1_2, 5_1_2, 3)
       lowercase_	:    List[str]           =     np.array([0.1568, 0.1738, 0.1695, 0.1693, 0.1507, 0.1705, 0.1547, 0.1751, 0.1949]			)

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




    def 				lowerCAmelCase__				(			self  :       Tuple			):






       '''simple docstring'''






       lowercase_	:    Tuple           =     StableDiffusionSAGPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"			)
       lowercase_	:    Any           =     sag_pipe.to(a			)
       sag_pipe.set_progress_bar_config(disable=a			)

       lowercase_	:    Union[str, Any]           =     "."
       lowercase_	:    Tuple           =     torch.manual_seed(0			)
       lowercase_	:    int           =     sag_pipe(
           [prompt]  ,     generator=a  ,     guidance_scale=7.5  ,     sag_scale=1.0  ,     num_inference_steps=2_0  ,     output_type="np"			)

       lowercase_	:    int           =     output.images

       lowercase_	:    Dict           =     image[0, -3:, -3:, -1]

       assert image.shape == (1, 5_1_2, 5_1_2, 3)
       lowercase_	:    Tuple           =     np.array([0.3459, 0.2876, 0.2537, 0.3002, 0.2671, 0.2160, 0.3026, 0.2262, 0.2371]			)

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





    def 				lowerCAmelCase__				(			self  :       Optional[int]			):






       '''simple docstring'''






       lowercase_	:    Optional[int]           =     StableDiffusionSAGPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"			)
       lowercase_	:    str           =     sag_pipe.to(a			)
       sag_pipe.set_progress_bar_config(disable=a			)

       lowercase_	:    str           =     "."
       lowercase_	:    Union[str, Any]           =     torch.manual_seed(0			)
       lowercase_	:    List[Any]           =     sag_pipe(
           [prompt]  ,     width=7_6_8  ,     height=5_1_2  ,     generator=a  ,     guidance_scale=7.5  ,     sag_scale=1.0  ,     num_inference_steps=2_0  ,     output_type="np"  ,     )

       lowercase_	:    List[str]           =     output.images

       assert image.shape == (1, 5_1_2, 7_6_8, 3)












'''simple docstring'''
def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase = 200							):


   """simple docstring"""




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

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


if __name__ == "__main__":
 assert solution(200) == 73682




