
import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import 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 PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


lowercase    :   Tuple		       =				False

@skip_mps
class __snake_case						( lowerCAmelCase   ,      lowerCAmelCase   ,      lowerCAmelCase   ,      unittest.TestCase	):
    _a						:		Dict=							StableDiffusionAttendAndExcitePipeline
    _a						:		str=							False
    _a						:		Any=							TEXT_TO_IMAGE_PARAMS
    _a						:		List[str]=							TEXT_TO_IMAGE_BATCH_PARAMS.union({"token_indices"}	)
    _a						:		List[str]=							TEXT_TO_IMAGE_IMAGE_PARAMS
    _a						:		Union[str, Any]=							TEXT_TO_IMAGE_IMAGE_PARAMS
    @classmethod
    def  _SCREAMING_SNAKE_CASE			(    cls ):



           '''simple docstring'''







           super().setUpClass()
           torch.use_deterministic_algorithms(lowerCamelCase__ )
    @classmethod
    def  _SCREAMING_SNAKE_CASE			(    cls ):



           '''simple docstring'''







           super().tearDownClass()
           torch.use_deterministic_algorithms(lowerCamelCase__ )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           torch.manual_seed(0 )
           lowercase				:	Union[str, Any]			      = 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						,attention_head_dim=(2, 4)						,use_linear_projection=lowerCamelCase__						,)
           lowercase				:	List[str]			      = DDIMScheduler(
               beta_start=0.00_085						,beta_end=0.012						,beta_schedule="""scaled_linear"""						,clip_sample=lowerCamelCase__						,set_alpha_to_one=lowerCamelCase__						,)
           torch.manual_seed(0 )
           lowercase				:	List[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				:	List[str]			      = 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						,hidden_act="""gelu"""						,projection_dim=512						,)
           lowercase				:	List[str]			      = CLIPTextModel(lowerCamelCase__ )
           lowercase				:	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  _SCREAMING_SNAKE_CASE			(    self						,snake_case						,snake_case=0 ):



           '''simple docstring'''







           if str(lowerCamelCase__ ).startswith("""mps""" ):
                  lowercase				:	Union[str, Any]			      = torch.manual_seed(lowerCamelCase__ )
           else:
                  lowercase				:	int			      = torch.Generator(device=lowerCamelCase__ ).manual_seed(lowerCamelCase__ )
           lowercase				:	Union[str, Any]			      = {
               'prompt': 'a cat and a frog',
               'token_indices': [2, 5],
               'generator': generator,
               'num_inference_steps': 1,
               'guidance_scale': 6.0,
               'output_type': 'numpy',
               'max_iter_to_alter': 2,
               'thresholds': {0: 0.7},
           }
           return inputs
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           lowercase				:	Any			      = 'cpu'

           lowercase				:	List[Any]			      = self.get_dummy_components()
           lowercase				:	Union[str, Any]			      = self.pipeline_class(**lowerCamelCase__ )
           pipe.to(lowerCamelCase__ )
           pipe.set_progress_bar_config(disable=lowerCamelCase__ )

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

           self.assertEqual(image.shape						,(1, 64, 64, 3) )
           lowercase				:	Union[str, Any]			      = np.array(
               [0.63_905_364, 0.62_897_307, 0.48_599_017, 0.5_133_624, 0.5_550_048, 0.45_769_516, 0.50_326_973, 0.5_023_139, 0.45_384_496] )
           lowercase				:	Tuple			      = np.abs(image_slice.flatten() - expected_slice ).max()
           self.assertLessEqual(lowerCamelCase__						,1e-3 )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           super().test_cpu_offload_forward_pass(expected_max_diff=5e-4 )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           self._test_inference_batch_consistent(batch_sizes=[1, 2] )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           self._test_inference_batch_single_identical(batch_size=2						,expected_max_diff=7e-4 )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3 )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4 )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           super().test_save_load_local(expected_max_difference=5e-4 )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           super().test_save_load_optional_components(expected_max_difference=4e-4 )






@require_torch_gpu
@slow
class __snake_case						( unittest.TestCase	):
    @classmethod
    def  _SCREAMING_SNAKE_CASE			(    cls ):



           '''simple docstring'''







           super().setUpClass()
           torch.use_deterministic_algorithms(lowerCamelCase__ )
    @classmethod
    def  _SCREAMING_SNAKE_CASE			(    cls ):



           '''simple docstring'''







           super().tearDownClass()
           torch.use_deterministic_algorithms(lowerCamelCase__ )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







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



           '''simple docstring'''







           lowercase				:	Optional[Any]			      = torch.manual_seed(51 )

           lowercase				:	Optional[Any]			      = StableDiffusionAttendAndExcitePipeline.from_pretrained(
               """CompVis/stable-diffusion-v1-4"""						,safety_checker=lowerCamelCase__						,torch_dtype=torch.floataa )
           pipe.to("""cuda""" )

           lowercase				:	Any			      = 'a painting of an elephant with glasses'
           lowercase				:	str			      = [5, 7]

           lowercase				:	int			      = pipe(
               prompt=lowerCamelCase__						,token_indices=lowerCamelCase__						,guidance_scale=7.5						,generator=lowerCamelCase__						,num_inference_steps=5						,max_iter_to_alter=5						,output_type="""numpy"""						,).images[0]

           lowercase				:	Tuple			      = load_numpy(
               """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy""" )
           assert np.abs((expected_image - image).max() ) < 5e-1





'''simple docstring'''
from math import ceil






def A__       (	UpperCAmelCase_ = 1_0_0_1				):
						_UpperCamelCase   :						int												=  1

						for i in range(1    ,    int(ceil(n / 2.0				)				)				):
												_UpperCamelCase   :						Dict												=  2 * i + 1
												_UpperCamelCase   :						Tuple												=  2 * i
												_UpperCamelCase   :						Any												=  total + 4 * odd**2 - 6 * even

						return total


if __name__ == "__main__":
					import sys

					if len(sys.argv) == 1:
										print(solution())
					else:
										try:
															snake_case_					:      Tuple    			=    int(sys.argv[1])
															print(solution(n))
										except ValueError:
															print('Invalid entry - please enter a number')


