



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     __lowerCAmelCase					(    A       ,		A       ,		unittest.TestCase		):
			UpperCamelCase           =  StableDiffusionSAGPipeline
			UpperCamelCase           =  TEXT_TO_IMAGE_PARAMS
			UpperCamelCase           =  TEXT_TO_IMAGE_BATCH_PARAMS
			UpperCamelCase           =  TEXT_TO_IMAGE_IMAGE_PARAMS
			UpperCamelCase           =  TEXT_TO_IMAGE_IMAGE_PARAMS
			UpperCamelCase           =  False



			def 					_lowerCamelCase (		self     :						Union[str, Any])     ->					List[Any]:



						"""simple docstring"""






						torch.manual_seed(0)
						_UpperCAmelCase	 =     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				,	)
						_UpperCAmelCase	 =     DDIMScheduler(
						    beta_start=0.0_0_0_8_5				,	beta_end=0.0_1_2				,	beta_schedule='scaled_linear'				,	clip_sample=A				,	set_alpha_to_one=A				,	)
						torch.manual_seed(0)
						_UpperCAmelCase	 =     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)
						_UpperCAmelCase	 =     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				,	)
						_UpperCAmelCase	 =     CLIPTextModel(A)
						_UpperCAmelCase	 =     CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

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



			def 					_lowerCamelCase (		self     :						Optional[int]				,	A     :						Tuple				,	A     :						List[str]=0)     ->					Tuple:



						"""simple docstring"""






						if str(A).startswith('mps'):
									_UpperCAmelCase	 =     torch.manual_seed(A)
						else:
									_UpperCAmelCase	 =     torch.Generator(device=A).manual_seed(A)
						_UpperCAmelCase	 =     {
						    'prompt': '.',
						    'generator': generator,
						    'num_inference_steps': 2,
						    'guidance_scale': 1.0,
						    'sag_scale': 1.0,
						    'output_type': 'numpy',
						}
						return inputs



			def 					_lowerCamelCase (		self     :						int)     ->					List[str]:



						"""simple docstring"""






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







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



			def 					_lowerCamelCase (		self     :						str)     ->					Union[str, Any]:



						"""simple docstring"""






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



			def 					_lowerCamelCase (		self     :						Tuple)     ->					str:



						"""simple docstring"""






						_UpperCAmelCase	 =     StableDiffusionSAGPipeline.from_pretrained('CompVis/stable-diffusion-v1-4')
						_UpperCAmelCase	 =     sag_pipe.to(A)
						sag_pipe.set_progress_bar_config(disable=A)

						_UpperCAmelCase	 =     '.'
						_UpperCAmelCase	 =     torch.manual_seed(0)
						_UpperCAmelCase	 =     sag_pipe(
						    [prompt]				,	generator=A				,	guidance_scale=7.5				,	sag_scale=1.0				,	num_inference_steps=20				,	output_type='np')

						_UpperCAmelCase	 =     output.images

						_UpperCAmelCase	 =     image[0, -3:, -3:, -1]

						assert image.shape == (1, 5_12, 5_12, 3)
						_UpperCAmelCase	 =     np.array([0.1_5_6_8, 0.1_7_3_8, 0.1_6_9_5, 0.1_6_9_3, 0.1_5_0_7, 0.1_7_0_5, 0.1_5_4_7, 0.1_7_5_1, 0.1_9_4_9])

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



			def 					_lowerCamelCase (		self     :						Tuple)     ->					Any:



						"""simple docstring"""






						_UpperCAmelCase	 =     StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base')
						_UpperCAmelCase	 =     sag_pipe.to(A)
						sag_pipe.set_progress_bar_config(disable=A)

						_UpperCAmelCase	 =     '.'
						_UpperCAmelCase	 =     torch.manual_seed(0)
						_UpperCAmelCase	 =     sag_pipe(
						    [prompt]				,	generator=A				,	guidance_scale=7.5				,	sag_scale=1.0				,	num_inference_steps=20				,	output_type='np')

						_UpperCAmelCase	 =     output.images

						_UpperCAmelCase	 =     image[0, -3:, -3:, -1]

						assert image.shape == (1, 5_12, 5_12, 3)
						_UpperCAmelCase	 =     np.array([0.3_4_5_9, 0.2_8_7_6, 0.2_5_3_7, 0.3_0_0_2, 0.2_6_7_1, 0.2_1_6_0, 0.3_0_2_6, 0.2_2_6_2, 0.2_3_7_1])

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



			def 					_lowerCamelCase (		self     :						List[Any])     ->					int:



						"""simple docstring"""






						_UpperCAmelCase	 =     StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base')
						_UpperCAmelCase	 =     sag_pipe.to(A)
						sag_pipe.set_progress_bar_config(disable=A)

						_UpperCAmelCase	 =     '.'
						_UpperCAmelCase	 =     torch.manual_seed(0)
						_UpperCAmelCase	 =     sag_pipe(
						    [prompt]				,	width=7_68				,	height=5_12				,	generator=A				,	guidance_scale=7.5				,	sag_scale=1.0				,	num_inference_steps=20				,	output_type='np'				,	)

						_UpperCAmelCase	 =     output.images

						assert image.shape == (1, 5_12, 7_68, 3)





from collections import Counter
from timeit import timeit





def 							A			(  _UpperCAmelCase       :     str = ""							,     )       ->				bool:







			'''simple docstring'''
			return sum(c % 2 for c in Counter(input_str.replace(' '							,     ''					).lower()					).values()					) < 2





def 							A			(  _UpperCAmelCase       :     str = ""					)       ->				bool:







			'''simple docstring'''
			if len(_UpperCAmelCase					) == 0:
						return True
			_UpperCAmelCase	 =     input_str.replace(' '							,     ''					).lower()
			# character_freq_dict: Stores the frequency of every character in the input string
			_UpperCAmelCase	 =     {}

			for character in lower_case_input_str:
						_UpperCAmelCase	 =     character_freq_dict.get(_UpperCAmelCase							,     0					) + 1
			_UpperCAmelCase	 =     0

			for character_count in character_freq_dict.values():
						if character_count % 2:
									odd_char += 1
			if odd_char > 1:
						return False
			return True





def 							A			(  _UpperCAmelCase       :     str = ""					)       ->				None:







			'''simple docstring'''
			print('\nFor string = '							,     _UpperCAmelCase							,     ':'					)
			print(
			    '> can_string_be_rearranged_as_palindrome_counter()'							,     '\tans ='							,     can_string_be_rearranged_as_palindrome_counter(_UpperCAmelCase					)							,     '\ttime ='							,     timeit(
			        'z.can_string_be_rearranged_as_palindrome_counter(z.check_str)'							,     setup='import __main__ as z'							,     )							,     'seconds'							,     )
			print(
			    '> can_string_be_rearranged_as_palindrome()'							,     '\tans ='							,     can_string_be_rearranged_as_palindrome(_UpperCAmelCase					)							,     '\ttime ='							,     timeit(
			        'z.can_string_be_rearranged_as_palindrome(z.check_str)'							,     setup='import __main__ as z'							,     )							,     'seconds'							,     )


if __name__ == "__main__":
							UpperCAmelCase__     = input(
							    "Enter string to determine if it can be rearranged as a palindrome or not: "
							).strip()
							benchmark(check_str)
							UpperCAmelCase__     = can_string_be_rearranged_as_palindrome_counter(check_str)
							print(f"""{check_str} can {"" if status else "not "}be rearranged as a palindrome""")
