



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


a_								=       False



@skip_mps
class 			__lowerCAmelCase  (						lowerCAmelCase__	,						lowerCAmelCase__	,						lowerCAmelCase__	,						unittest.TestCase ):
 lowerCAmelCase__							       =	StableDiffusionAttendAndExcitePipeline
 lowerCAmelCase__							       =	False
 lowerCAmelCase__							       =	TEXT_TO_IMAGE_PARAMS
 lowerCAmelCase__							       =	TEXT_TO_IMAGE_BATCH_PARAMS.union({"""token_indices"""} )
 lowerCAmelCase__							       =	TEXT_TO_IMAGE_IMAGE_PARAMS
 lowerCAmelCase__							       =	TEXT_TO_IMAGE_IMAGE_PARAMS




 @classmethod
 def 							lowerCamelCase   (    cls					):



    '''simple docstring'''
    super().setUpClass()
    torch.use_deterministic_algorithms(__UpperCAmelCase					)




 @classmethod
 def 							lowerCamelCase   (    cls					):



    '''simple docstring'''
    super().tearDownClass()
    torch.use_deterministic_algorithms(__UpperCAmelCase					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    torch.manual_seed(0					)
    __lowerCamelCase    				=     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=__UpperCAmelCase						,					)
    __lowerCamelCase    				=     DDIMScheduler(
        beta_start=0.00_085						,					beta_end=0.012						,					beta_schedule='''scaled_linear'''						,					clip_sample=__UpperCAmelCase						,					set_alpha_to_one=__UpperCAmelCase						,					)
    torch.manual_seed(0					)
    __lowerCamelCase    				=     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					)
    __lowerCamelCase    				=     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=1000						,					hidden_act='''gelu'''						,					projection_dim=512						,					)
    __lowerCamelCase    				=     CLIPTextModel(__UpperCAmelCase					)
    __lowerCamelCase    				=     CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)

    __lowerCamelCase    				=     {
        '''unet''': unet,
        '''scheduler''': scheduler,
        '''vae''': vae,
        '''text_encoder''': text_encoder,
        '''tokenizer''': tokenizer,
        '''safety_checker''': None,
        '''feature_extractor''': None,
    }

    return components




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase=0					):



    '''simple docstring'''
    if str(__UpperCAmelCase					).startswith('''mps'''					):
       __lowerCamelCase    				=     torch.manual_seed(__UpperCAmelCase					)
    else:
       __lowerCamelCase    				=     torch.Generator(device=__UpperCAmelCase					).manual_seed(__UpperCAmelCase					)
    __lowerCamelCase    				=     __lowerCamelCase    				=     {
        '''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 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     '''cpu'''

    __lowerCamelCase    				=     self.get_dummy_components()
    __lowerCamelCase    				=     self.pipeline_class(**__UpperCAmelCase					)
    pipe.to(__UpperCAmelCase					)
    pipe.set_progress_bar_config(disable=__UpperCAmelCase					)

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

    self.assertEqual(image.shape						,					(1, 64, 64, 3)					)
    __lowerCamelCase    				=     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]					)
    __lowerCamelCase    				=     np.abs(image_slice.flatten() - expected_slice					).max()
    self.assertLessEqual(__UpperCAmelCase						,					1E-3					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    super().test_cpu_offload_forward_pass(expected_max_diff=5E-4					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
    self._test_inference_batch_consistent(batch_sizes=[1, 2]					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    self._test_inference_batch_single_identical(batch_size=2						,					expected_max_diff=7E-4					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    super().test_save_load_local(expected_max_difference=5E-4					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    super().test_save_load_optional_components(expected_max_difference=4E-4					)



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




 @classmethod
 def 							lowerCamelCase   (    cls					):



    '''simple docstring'''
    super().setUpClass()
    torch.use_deterministic_algorithms(__UpperCAmelCase					)




 @classmethod
 def 							lowerCamelCase   (    cls					):



    '''simple docstring'''
    super().tearDownClass()
    torch.use_deterministic_algorithms(__UpperCAmelCase					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     torch.manual_seed(51					)

    __lowerCamelCase    				=     StableDiffusionAttendAndExcitePipeline.from_pretrained(
        '''CompVis/stable-diffusion-v1-4'''						,					safety_checker=__UpperCAmelCase						,					torch_dtype=torch.floataa					)
    pipe.to('''cuda'''					)

    __lowerCamelCase    				=     '''a painting of an elephant with glasses'''
    __lowerCamelCase    				=     [5, 7]

    __lowerCamelCase    				=     pipe(
        prompt=__UpperCAmelCase						,					token_indices=__UpperCAmelCase						,					guidance_scale=7.5						,					generator=__UpperCAmelCase						,					num_inference_steps=5						,					max_iter_to_alter=5						,					output_type='''numpy'''						,					).images[0]

    __lowerCamelCase    				=     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











from __future__ import annotations





def 		a__      (		_UpperCamelCase      :			int | float | str			,_UpperCamelCase      :			int | float | str				):
   if nth_term == "":
      return [""]
   __lowerCamelCase    				=     int(_UpperCamelCase				)
   __lowerCamelCase    				=     int(_UpperCamelCase				)
   __lowerCamelCase    				=     []
   for temp in range(int(_UpperCamelCase				)				):
      series.append(F"""1 / {pow(temp + 1			,int(_UpperCamelCase				)				)}""" if series else '''1'''				)
   return series


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  a_								=       int(input("""Enter the last number (nth term) of the P-Series"""))
  a_								=       int(input("""Enter the power for  P-Series"""))
  print("""Formula of P-Series => 1+1/2^p+1/3^p ..... 1/n^p""")
  print(p_series(nth_term, power))






