


import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPanoramaPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

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()
@skip_mps
class 		__magic_name__						(snake_case_   ,snake_case_   ,unittest.TestCase				):





     '''simple docstring'''



     __lowercase				:							Tuple	   =       StableDiffusionPanoramaPipeline
     __lowercase				:							int	   =       TEXT_TO_IMAGE_PARAMS
     __lowercase				:							Any	   =       TEXT_TO_IMAGE_BATCH_PARAMS
     __lowercase				:							Union[str, Any]	   =       TEXT_TO_IMAGE_IMAGE_PARAMS
     __lowercase				:							Dict	   =       TEXT_TO_IMAGE_IMAGE_PARAMS

     def 	SCREAMING_SNAKE_CASE__						(					self:Tuple   ):
       torch.manual_seed(0   )
       snake_case__						= UNetaDConditionModel(
           block_out_channels=(32, 64)     ,		layers_per_block=1     ,		sample_size=32     ,		in_channels=4     ,		out_channels=4     ,		down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')     ,		up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')     ,		cross_attention_dim=32     ,		)
       snake_case__						= DDIMScheduler()
       torch.manual_seed(0   )
       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   )
       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=10_00     ,		)
       snake_case__						= CLIPTextModel(_a   )
       snake_case__						= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''   )

       snake_case__						= {
           '''unet''': unet,
           '''scheduler''': scheduler,
           '''vae''': vae,
           '''text_encoder''': text_encoder,
           '''tokenizer''': tokenizer,
           '''safety_checker''': None,
           '''feature_extractor''': None,
       }
       return components

     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[Any]     ,		_a:str     ,		_a:Optional[Any]=0   ):
       snake_case__						= torch.manual_seed(_a   )
       snake_case__						= {
           '''prompt''': '''a photo of the dolomites''',
           '''generator''': generator,
           # Setting height and width to None to prevent OOMs on CPU.
           '''height''': None,
           '''width''': None,
           '''num_inference_steps''': 1,
           '''guidance_scale''': 6.0,
           '''output_type''': '''numpy''',
       }
       return inputs

     def 	SCREAMING_SNAKE_CASE__						(					self:List[str]   ):
       snake_case__						= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
       snake_case__						= self.get_dummy_components()
       snake_case__						= StableDiffusionPanoramaPipeline(**_a   )
       snake_case__						= sd_pipe.to(_a   )
       sd_pipe.set_progress_bar_config(disable=_a   )

       snake_case__						= self.get_dummy_inputs(_a   )
       snake_case__						= sd_pipe(**_a   ).images
       snake_case__						= image[0, -3:, -3:, -1]
       assert image.shape == (1, 64, 64, 3)

       snake_case__						= np.array([0.6186, 0.5374, 0.4915, 0.4135, 0.4114, 0.4563, 0.5128, 0.4977, 0.4757]   )

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

     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       super().test_inference_batch_consistent(batch_sizes=[1, 2]   )

     def 	SCREAMING_SNAKE_CASE__						(					self:List[str]   ):
       super().test_inference_batch_single_identical(batch_size=2     ,		expected_max_diff=3.25e-3   )

     def 	SCREAMING_SNAKE_CASE__						(					self:int   ):
       snake_case__						= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
       snake_case__						= self.get_dummy_components()
       snake_case__						= StableDiffusionPanoramaPipeline(**_a   )
       snake_case__						= sd_pipe.to(_a   )
       sd_pipe.set_progress_bar_config(disable=_a   )

       snake_case__						= self.get_dummy_inputs(_a   )
       snake_case__						= '''french fries'''
       snake_case__						= sd_pipe(**_a     ,		negative_prompt=_a   )
       snake_case__						= output.images
       snake_case__						= image[0, -3:, -3:, -1]

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

       snake_case__						= np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757]   )

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

     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       snake_case__						= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
       snake_case__						= self.get_dummy_components()
       snake_case__						= StableDiffusionPanoramaPipeline(**_a   )
       snake_case__						= sd_pipe.to(_a   )
       sd_pipe.set_progress_bar_config(disable=_a   )

       snake_case__						= self.get_dummy_inputs(_a   )
       snake_case__						= sd_pipe(**_a     ,		view_batch_size=2   )
       snake_case__						= output.images
       snake_case__						= image[0, -3:, -3:, -1]

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

       snake_case__						= np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757]   )

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

     def 	SCREAMING_SNAKE_CASE__						(					self:str   ):
       snake_case__						= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
       snake_case__						= self.get_dummy_components()
       snake_case__						= EulerAncestralDiscreteScheduler(
           beta_start=0.00085     ,		beta_end=0.012     ,		beta_schedule='''scaled_linear'''   )
       snake_case__						= StableDiffusionPanoramaPipeline(**_a   )
       snake_case__						= sd_pipe.to(_a   )
       sd_pipe.set_progress_bar_config(disable=_a   )

       snake_case__						= self.get_dummy_inputs(_a   )
       snake_case__						= sd_pipe(**_a   ).images
       snake_case__						= image[0, -3:, -3:, -1]

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

       snake_case__						= np.array([0.4024, 0.6510, 0.4901, 0.5378, 0.5813, 0.5622, 0.4795, 0.4467, 0.4952]   )

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







     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       snake_case__						= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
       snake_case__						= self.get_dummy_components()
       snake_case__						= PNDMScheduler(
           beta_start=0.00085     ,		beta_end=0.012     ,		beta_schedule='''scaled_linear'''     ,		skip_prk_steps=_a   )
       snake_case__						= StableDiffusionPanoramaPipeline(**_a   )
       snake_case__						= sd_pipe.to(_a   )
       sd_pipe.set_progress_bar_config(disable=_a   )

       snake_case__						= self.get_dummy_inputs(_a   )
       snake_case__						= sd_pipe(**_a   ).images
       snake_case__						= image[0, -3:, -3:, -1]

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

       snake_case__						= np.array([0.6391, 0.6291, 0.4861, 0.5134, 0.5552, 0.4578, 0.5032, 0.5023, 0.4539]   )

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




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





     '''simple docstring'''



     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()

     def 	SCREAMING_SNAKE_CASE__						(					self:Dict     ,		_a:Any=0   ):
       snake_case__						= torch.manual_seed(_a   )
       snake_case__						= {
           '''prompt''': '''a photo of the dolomites''',
           '''generator''': generator,
           '''num_inference_steps''': 3,
           '''guidance_scale''': 7.5,
           '''output_type''': '''numpy''',
       }
       return inputs

     def 	SCREAMING_SNAKE_CASE__						(					self:str   ):
       snake_case__						= '''stabilityai/stable-diffusion-2-base'''
       snake_case__						= DDIMScheduler.from_pretrained(_a     ,		subfolder='''scheduler'''   )
       snake_case__						= StableDiffusionPanoramaPipeline.from_pretrained(_a     ,		scheduler=_a     ,		safety_checker=_a   )
       pipe.to(_a   )
       pipe.set_progress_bar_config(disable=_a   )
       pipe.enable_attention_slicing()

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

       assert image.shape == (1, 5_12, 20_48, 3)

       snake_case__						= np.array(
           [
               0.36968392,
               0.27025372,
               0.32446766,
               0.28379387,
               0.36363274,
               0.30733347,
               0.27100027,
               0.27054125,
               0.25536096,
           ]   )

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

     def 	SCREAMING_SNAKE_CASE__						(					self:Dict   ):
       snake_case__						= StableDiffusionPanoramaPipeline.from_pretrained(
           '''stabilityai/stable-diffusion-2-base'''     ,		safety_checker=_a   )
       snake_case__						= LMSDiscreteScheduler.from_config(pipe.scheduler.config   )
       pipe.to(_a   )
       pipe.set_progress_bar_config(disable=_a   )
       pipe.enable_attention_slicing()

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

       assert image.shape == (1, 5_12, 20_48, 3)

       snake_case__						= np.array(
           [
               [
                   0.0,
                   0.0,
                   0.0,
                   0.0,
                   0.0,
                   0.0,
                   0.0,
                   0.0,
                   0.0,
               ]
           ]   )

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

     def 	SCREAMING_SNAKE_CASE__						(					self:int   ):
       snake_case__						= 0

       def callback_fn(_a:int     ,		_a:int     ,		_a:torch.FloatTensor   ) -> None:
         snake_case__						= True
         nonlocal number_of_steps
         number_of_steps += 1
         if step == 1:
           snake_case__						= latents.detach().cpu().numpy()
           assert latents.shape == (1, 4, 64, 2_56)
           snake_case__						= latents[0, -3:, -3:, -1]

           snake_case__						= np.array(
               [
                   0.18681869,
                   0.33907816,
                   0.5361276,
                   0.14432865,
                   -0.02856611,
                   -0.73941123,
                   0.23397987,
                   0.47322682,
                   -0.37823164,
               ]   )
           assert np.abs(latents_slice.flatten() - expected_slice   ).max() < 5e-2
         elif step == 2:
           snake_case__						= latents.detach().cpu().numpy()
           assert latents.shape == (1, 4, 64, 2_56)
           snake_case__						= latents[0, -3:, -3:, -1]

           snake_case__						= np.array(
               [
                   0.18539645,
                   0.33987248,
                   0.5378559,
                   0.14437142,
                   -0.02455261,
                   -0.7338317,
                   0.23990755,
                   0.47356272,
                   -0.3786505,
               ]   )

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

       snake_case__						= False

       snake_case__						= '''stabilityai/stable-diffusion-2-base'''
       snake_case__						= DDIMScheduler.from_pretrained(_a     ,		subfolder='''scheduler'''   )
       snake_case__						= StableDiffusionPanoramaPipeline.from_pretrained(_a     ,		scheduler=_a     ,		safety_checker=_a   )
       snake_case__						= pipe.to(_a   )
       pipe.set_progress_bar_config(disable=_a   )
       pipe.enable_attention_slicing()

       snake_case__						= self.get_inputs()
       pipe(**_a     ,		callback=_a     ,		callback_steps=1   )
       assert callback_fn.has_been_called
       assert number_of_steps == 3







     def 	SCREAMING_SNAKE_CASE__						(					self:Tuple   ):
       torch.cuda.empty_cache()
       torch.cuda.reset_max_memory_allocated()
       torch.cuda.reset_peak_memory_stats()

       snake_case__						= '''stabilityai/stable-diffusion-2-base'''
       snake_case__						= DDIMScheduler.from_pretrained(_a     ,		subfolder='''scheduler'''   )
       snake_case__						= StableDiffusionPanoramaPipeline.from_pretrained(_a     ,		scheduler=_a     ,		safety_checker=_a   )
       snake_case__						= pipe.to(_a   )
       pipe.set_progress_bar_config(disable=_a   )
       pipe.enable_attention_slicing(1   )
       pipe.enable_sequential_cpu_offload()

       snake_case__						= self.get_inputs()
       snake_case__						= pipe(**_a   )

       snake_case__						= torch.cuda.max_memory_allocated()
       # make sure that less than 5.2 GB is allocated
       assert mem_bytes < 5.5 * 10**9








'''simple docstring'''




from math import factorial



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_	):


		"""simple docstring"""



		if n < k or k < 0:
				raise ValueError("""Please enter positive integers for n and k where n >= k"""	)
		return factorial(lowerCamelCase_	) // (factorial(lowerCamelCase_	) * factorial(n - k	))


if __name__ == "__main__":
							print(
							    """The number of five-card hands possible from a standard""",
							    f'''fifty-two card deck is: {combinations(52, 5)}\n''',
							)

							print(
							    """If a class of 40 students must be arranged into groups of""",
							    f'''4 for group projects, there are {combinations(40, 4)} ways''',
							    """to arrange them.\n""",
							)

							print(
							    """If 10 teams are competing in a Formula One race, there""",
							    f'''are {combinations(10, 3)} ways that first, second and''',
							    """third place can be awarded.""",
							)



