






"""simple docstring"""





import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    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 		_a   (						__a				,     __a				,     unittest.TestCase    ):





   '''simple docstring'''






   UpperCamelCase__			     =				StableDiffusionParadigmsPipeline
   UpperCamelCase__			     =				TEXT_TO_IMAGE_PARAMS
   UpperCamelCase__			     =				TEXT_TO_IMAGE_BATCH_PARAMS
   UpperCamelCase__			     =				TEXT_TO_IMAGE_IMAGE_PARAMS
   UpperCamelCase__			     =				TEXT_TO_IMAGE_IMAGE_PARAMS





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




          '''simple docstring'''




          torch.manual_seed(0)
          lowercase__:				Tuple			  =			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 ,      attention_head_dim=(2, 4) ,      use_linear_projection=lowerCAmelCase__ ,      )
          lowercase__:				Union[str, Any]			  =			DDIMParallelScheduler(
              beta_start=0.0_00_85 ,      beta_end=0.0_12 ,      beta_schedule="scaled_linear" ,      clip_sample=lowerCAmelCase__ ,      set_alpha_to_one=lowerCAmelCase__ ,      )
          torch.manual_seed(0)
          lowercase__:				str			  =			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 ,      sample_size=128 ,      )
          torch.manual_seed(0)
          lowercase__:				Any			  =			CLIPTextConfig(
              bos_token_id=0 ,      eos_token_id=2 ,      hidden_size=32 ,      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 ,      hidden_act="gelu" ,      projection_dim=512 ,      )
          lowercase__:				List[Any]			  =			CLIPTextModel(lowerCAmelCase__)
          lowercase__:				Tuple			  =			CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")

          lowercase__:				Optional[int]			  =			{
              """unet""": unet,
              """scheduler""": scheduler,
              """vae""": vae,
              """text_encoder""": text_encoder,
              """tokenizer""": tokenizer,
              """safety_checker""": None,
              """feature_extractor""": None,
          }
          return components





   def __lowercase				(    self ,      UpperCAmelCase_ ,      UpperCAmelCase_=0)       ->					int:




          '''simple docstring'''




          if str(lowerCAmelCase__).startswith("mps"):
                 lowercase__:				Optional[int]			  =			torch.manual_seed(lowerCAmelCase__)
          else:
                 lowercase__:				int			  =			torch.Generator(device=lowerCAmelCase__).manual_seed(lowerCAmelCase__)
          lowercase__:				str			  =			{
              """prompt""": """a photograph of an astronaut riding a horse""",
              """generator""": generator,
              """num_inference_steps""": 10,
              """guidance_scale""": 6.0,
              """output_type""": """numpy""",
              """parallel""": 3,
              """debug""": True,
          }
          return inputs





   def __lowercase				(    self)       ->					List[Any]:




          '''simple docstring'''




          lowercase__:				List[str]			  =			"""cpu"""  # ensure determinism for the device-dependent torch.Generator
          lowercase__:				Optional[int]			  =			self.get_dummy_components()
          lowercase__:				List[str]			  =			StableDiffusionParadigmsPipeline(**lowerCAmelCase__)
          lowercase__:				Optional[Any]			  =			sd_pipe.to(lowerCAmelCase__)
          sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

          lowercase__:				Optional[Any]			  =			self.get_dummy_inputs(lowerCAmelCase__)
          lowercase__:				Tuple			  =			sd_pipe(**lowerCAmelCase__).images
          lowercase__:				Tuple			  =			image[0, -3:, -3:, -1]
          assert image.shape == (1, 64, 64, 3)

          lowercase__:				Dict			  =			np.array([0.47_73, 0.54_17, 0.47_23, 0.49_25, 0.56_31, 0.47_52, 0.52_40, 0.49_35, 0.50_23])

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





   def __lowercase				(    self)       ->					Tuple:




          '''simple docstring'''




          lowercase__:				Dict			  =			"""cpu"""  # ensure determinism for the device-dependent torch.Generator
          lowercase__:				List[str]			  =			self.get_dummy_components()
          torch.manual_seed(0)
          lowercase__:				Tuple			  =			DDPMParallelScheduler()
          torch.manual_seed(0)
          lowercase__:				Optional[Any]			  =			StableDiffusionParadigmsPipeline(**lowerCAmelCase__)
          lowercase__:				Union[str, Any]			  =			sd_pipe.to(lowerCAmelCase__)
          sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

          lowercase__:				Union[str, Any]			  =			self.get_dummy_inputs(lowerCAmelCase__)
          lowercase__:				int			  =			sd_pipe(**lowerCAmelCase__).images
          lowercase__:				int			  =			image[0, -3:, -3:, -1]
          assert image.shape == (1, 64, 64, 3)

          lowercase__:				Tuple			  =			np.array([0.35_73, 0.44_20, 0.49_60, 0.47_99, 0.37_96, 0.38_79, 0.48_19, 0.43_65, 0.44_68])

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





   def __lowercase				(    self)       ->					Optional[Any]:




          '''simple docstring'''




          super().test_inference_batch_consistent(batch_sizes=[1, 2])





   def __lowercase				(    self)       ->					List[Any]:




          '''simple docstring'''




          super().test_inference_batch_single_identical(batch_size=2 ,      expected_max_diff=3E-3)





   def __lowercase				(    self)       ->					Dict:




          '''simple docstring'''




          lowercase__:				str			  =			"""cpu"""  # ensure determinism for the device-dependent torch.Generator
          lowercase__:				Optional[Any]			  =			self.get_dummy_components()
          lowercase__:				Optional[Any]			  =			StableDiffusionParadigmsPipeline(**lowerCAmelCase__)
          lowercase__:				Optional[int]			  =			sd_pipe.to(lowerCAmelCase__)
          sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

          lowercase__:				Dict			  =			self.get_dummy_inputs(lowerCAmelCase__)
          lowercase__:				int			  =			"""french fries"""
          lowercase__:				Optional[Any]			  =			sd_pipe(**lowerCAmelCase__ ,      negative_prompt=lowerCAmelCase__)
          lowercase__:				int			  =			output.images
          lowercase__:				Tuple			  =			image[0, -3:, -3:, -1]

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

          lowercase__:				int			  =			np.array([0.47_71, 0.54_20, 0.46_83, 0.49_18, 0.56_36, 0.47_25, 0.52_30, 0.49_23, 0.50_15])

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







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





   '''simple docstring'''






   def __lowercase				(    self)       ->					List[Any]:




          '''simple docstring'''




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





   def __lowercase				(    self ,      UpperCAmelCase_=0)       ->					Optional[Any]:




          '''simple docstring'''




          lowercase__:				Any			  =			torch.Generator(device=lowerCAmelCase__).manual_seed(lowerCAmelCase__)
          lowercase__:				int			  =			{
              """prompt""": """a photograph of an astronaut riding a horse""",
              """generator""": generator,
              """num_inference_steps""": 10,
              """guidance_scale""": 7.5,
              """output_type""": """numpy""",
              """parallel""": 3,
              """debug""": True,
          }
          return inputs





   def __lowercase				(    self)       ->					List[str]:




          '''simple docstring'''




          lowercase__:				Any			  =			"""stabilityai/stable-diffusion-2-base"""
          lowercase__:				int			  =			DDIMParallelScheduler.from_pretrained(lowerCAmelCase__ ,      subfolder="scheduler")
          lowercase__:				str			  =			StableDiffusionParadigmsPipeline.from_pretrained(lowerCAmelCase__ ,      scheduler=lowerCAmelCase__ ,      safety_checker=lowerCAmelCase__)
          pipe.to(lowerCAmelCase__)
          pipe.set_progress_bar_config(disable=lowerCAmelCase__)
          pipe.enable_attention_slicing()

          lowercase__:				List[Any]			  =			self.get_inputs()
          lowercase__:				Union[str, Any]			  =			pipe(**lowerCAmelCase__).images
          lowercase__:				int			  =			image[0, -3:, -3:, -1].flatten()

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

          lowercase__:				Union[str, Any]			  =			np.array([0.96_22, 0.96_02, 0.97_48, 0.95_91, 0.96_30, 0.96_91, 0.96_61, 0.96_31, 0.97_41])

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








'''simple docstring'''

from __future__ import annotations







def __A  (    lowerCAmelCase_       ):
     _UpperCAmelCase					:  Optional[int]         =    {1}
     _UpperCAmelCase					:  Union[str, Any]         =    [1]
     for _ in range(2 ,       depth + 1       ):
          _UpperCAmelCase					:  Dict         =    [*previous_coefficients, 0]
          _UpperCAmelCase					:  int         =    [0, *previous_coefficients]
          _UpperCAmelCase					:  List[Any]         =    []
          for x, y in zip(lowerCAmelCase_ ,       lowerCAmelCase_       ):
               coefficients.add(x + y       )
               previous_coefficients.append(x + y       )
     return coefficients







def __A  (    lowerCAmelCase_       ):
     _UpperCAmelCase					:  Dict         =    set()
     for number in unique_coefficients:
          _UpperCAmelCase					:  Tuple         =    2
          _UpperCAmelCase					:  List[str]         =    number
          while divisor**2 <= copy_number:
               _UpperCAmelCase					:  Tuple         =    0
               while copy_number % divisor == 0:
                    copy_number //= divisor
                    multiplicity += 1
               if multiplicity >= 2:
                    non_squarefrees.add(lowerCAmelCase_       )
                    break
               divisor += 1

     return unique_coefficients.difference(lowerCAmelCase_       )







def __A  (    lowerCAmelCase_ = 51       ):
     _UpperCAmelCase					:  List[str]         =    get_pascal_triangle_unique_coefficients(lowerCAmelCase_       )
     _UpperCAmelCase					:  Optional[Any]         =    get_squarefrees(lowerCAmelCase_       )
     return sum(lowerCAmelCase_       )


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


