


'''simple docstring'''
import gc
import random
import unittest

import numpy as np
import torch

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetPipeline,
    KandinskyVaaPriorPipeline,
    UNetaDConditionModel,
    VQModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()
class        lowercase     (							A__     ,		unittest.TestCase ):

		"""simple docstring"""

		_a   			=    KandinskyVaaControlnetPipeline
		_a   			=    ['image_embeds', 'negative_image_embeds', 'hint']
		_a   			=    ['image_embeds', 'negative_image_embeds', 'hint']
		_a   			=    [
		    'generator',
		    'height',
		    'width',
		    'latents',
		    'guidance_scale',
		    'num_inference_steps',
		    'return_dict',
		    'guidance_scale',
		    'num_images_per_prompt',
		    'output_type',
		    'return_dict',
		]
		_a   			=    False




		@property
		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							return 32




		@property
		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							return 32




		@property
		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							return self.time_input_dim




		@property
		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							return self.time_input_dim * 4




		@property
		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							return 100




		@property
		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							torch.manual_seed(0							)

							UpperCamelCase__       :Optional[Any]							 =			{
							    '''in_channels''': 8,
							    # Out channels is double in channels because predicts mean and variance
							    '''out_channels''': 8,
							    '''addition_embed_type''': '''image_hint''',
							    '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
							    '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
							    '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
							    '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
							    '''layers_per_block''': 1,
							    '''encoder_hid_dim''': self.text_embedder_hidden_size,
							    '''encoder_hid_dim_type''': '''image_proj''',
							    '''cross_attention_dim''': self.cross_attention_dim,
							    '''attention_head_dim''': 4,
							    '''resnet_time_scale_shift''': '''scale_shift''',
							    '''class_embed_type''': None,
							}

							UpperCamelCase__       :Dict							 =			UNetaDConditionModel(**UpperCamelCase_							)
							return model




		@property
		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							return {
							    "block_out_channels": [32, 32, 64, 64],
							    "down_block_types": [
							        "DownEncoderBlock2D",
							        "DownEncoderBlock2D",
							        "DownEncoderBlock2D",
							        "AttnDownEncoderBlock2D",
							    ],
							    "in_channels": 3,
							    "latent_channels": 4,
							    "layers_per_block": 1,
							    "norm_num_groups": 8,
							    "norm_type": "spatial",
							    "num_vq_embeddings": 12,
							    "out_channels": 3,
							    "up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
							    "vq_embed_dim": 4,
							}




		@property
		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							torch.manual_seed(0							)
							UpperCamelCase__       :Optional[int]							 =			VQModel(**self.dummy_movq_kwargs							)
							return model




		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							UpperCamelCase__       :List[Any]							 =			self.dummy_unet
							UpperCamelCase__       :Optional[int]							 =			self.dummy_movq

							UpperCamelCase__       :List[Any]							 =			DDIMScheduler(
							    num_train_timesteps=1000   ,       beta_schedule='''linear'''   ,       beta_start=0.00085   ,       beta_end=0.012   ,       clip_sample=UpperCamelCase_   ,       set_alpha_to_one=UpperCamelCase_   ,       steps_offset=1   ,       prediction_type='''epsilon'''   ,       thresholding=UpperCamelCase_   ,       )

							UpperCamelCase__       :int							 =			{
							    '''unet''': unet,
							    '''scheduler''': scheduler,
							    '''movq''': movq,
							}
							return components




		def    lowerCAmelCase__    (		self   ,       UpperCamelCase_   ,       UpperCamelCase_=0							):

							'''simple docstring'''


							UpperCamelCase__       :Any							 =			floats_tensor((1, self.text_embedder_hidden_size)   ,       rng=random.Random(UpperCamelCase_							)							).to(UpperCamelCase_							)
							UpperCamelCase__       :Optional[Any]							 =			floats_tensor((1, self.text_embedder_hidden_size)   ,       rng=random.Random(seed + 1							)							).to(
							    UpperCamelCase_							)

							# create hint
							UpperCamelCase__       :Dict							 =			floats_tensor((1, 3, 64, 64)   ,       rng=random.Random(UpperCamelCase_							)							).to(UpperCamelCase_							)

							if str(UpperCamelCase_							).startswith('''mps'''							):
												UpperCamelCase__       :List[str]							 =			torch.manual_seed(UpperCamelCase_							)
							else:
												UpperCamelCase__       :str							 =			torch.Generator(device=UpperCamelCase_							).manual_seed(UpperCamelCase_							)
							UpperCamelCase__       :Optional[int]							 =			{
							    '''image_embeds''': image_embeds,
							    '''negative_image_embeds''': negative_image_embeds,
							    '''hint''': hint,
							    '''generator''': generator,
							    '''height''': 64,
							    '''width''': 64,
							    '''guidance_scale''': 4.0,
							    '''num_inference_steps''': 2,
							    '''output_type''': '''np''',
							}
							return inputs




		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							UpperCamelCase__       :Optional[Any]							 =			'''cpu'''

							UpperCamelCase__       :Union[str, Any]							 =			self.get_dummy_components()

							UpperCamelCase__       :Dict							 =			self.pipeline_class(**UpperCamelCase_							)
							UpperCamelCase__       :Tuple							 =			pipe.to(UpperCamelCase_							)

							pipe.set_progress_bar_config(disable=UpperCamelCase_							)

							UpperCamelCase__       :Tuple							 =			pipe(**self.get_dummy_inputs(UpperCamelCase_							)							)
							UpperCamelCase__       :Any							 =			output.images

							UpperCamelCase__       :str							 =			pipe(
							    **self.get_dummy_inputs(UpperCamelCase_							)   ,       return_dict=UpperCamelCase_   ,       )[0]

							UpperCamelCase__       :List[Any]							 =			image[0, -3:, -3:, -1]
							UpperCamelCase__       :Tuple							 =			image_from_tuple[0, -3:, -3:, -1]

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

							UpperCamelCase__       :Optional[int]							 =			np.array(
							    [0.6959826, 0.868279, 0.7558092, 0.68769467, 0.85805804, 0.65977496, 0.44885302, 0.5959111, 0.4251595]							)

							assert (
							    np.abs(image_slice.flatten() - expected_slice							).max() < 1e-2
							), F''' expected_slice {expected_slice}, but got {image_slice.flatten()}'''

							assert (
							    np.abs(image_from_tuple_slice.flatten() - expected_slice							).max() < 1e-2
							), F''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'''



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

		"""simple docstring"""

		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


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




		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							UpperCamelCase__       :str							 =			load_numpy(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
							    '''/kandinskyv22/kandinskyv22_controlnet_robotcat_fp16.npy'''							)

							UpperCamelCase__       :List[str]							 =			load_image(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
							    '''/kandinskyv22/hint_image_cat.png'''							)
							UpperCamelCase__       :int							 =			torch.from_numpy(np.array(UpperCamelCase_							)							).float() / 255.0
							UpperCamelCase__       :Union[str, Any]							 =			hint.permute(2   ,       0   ,       1							).unsqueeze(0							)

							UpperCamelCase__       :str							 =			KandinskyVaaPriorPipeline.from_pretrained(
							    '''kandinsky-community/kandinsky-2-2-prior'''   ,       torch_dtype=torch.floataa							)
							pipe_prior.to(UpperCamelCase_							)

							UpperCamelCase__       :Dict							 =			KandinskyVaaControlnetPipeline.from_pretrained(
							    '''kandinsky-community/kandinsky-2-2-controlnet-depth'''   ,       torch_dtype=torch.floataa							)
							UpperCamelCase__       :Dict							 =			pipeline.to(UpperCamelCase_							)
							pipeline.set_progress_bar_config(disable=UpperCamelCase_							)

							UpperCamelCase__       :Optional[Any]							 =			'''A robot, 4k photo'''

							UpperCamelCase__       :Optional[Any]							 =			torch.Generator(device='''cuda'''							).manual_seed(0							)
							UpperCamelCase__       :List[Any]							 =			pipe_prior(
							    UpperCamelCase_   ,       generator=UpperCamelCase_   ,       num_inference_steps=5   ,       negative_prompt=''''''   ,       ).to_tuple()

							UpperCamelCase__       :Optional[Any]							 =			torch.Generator(device='''cuda'''							).manual_seed(0							)
							UpperCamelCase__       :Tuple							 =			pipeline(
							    image_embeds=UpperCamelCase_   ,       negative_image_embeds=UpperCamelCase_   ,       hint=UpperCamelCase_   ,       generator=UpperCamelCase_   ,       num_inference_steps=100   ,       output_type='''np'''   ,       )

							UpperCamelCase__       :List[str]							 =			output.images[0]

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

							assert_mean_pixel_difference(UpperCamelCase_   ,       UpperCamelCase_							)



'''simple docstring'''
from collections import Counter
from timeit import timeit


def       a				(      __a = ""			, )  ->     bool:



					'''simple docstring'''






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


def       a				(      __a = ""       )  ->     bool:



					'''simple docstring'''






					if len(__a       ) == 0:
										return True
					UpperCamelCase__       :List[Any]							 =			input_str.replace(''' '''			, ''''''       ).lower()
					# character_freq_dict: Stores the frequency of every character in the input string
					UpperCamelCase__       :dict[str, int]							 =			{}

					for character in lower_case_input_str:
										UpperCamelCase__       :Optional[int]							 =			character_freq_dict.get(__a			, 0       ) + 1
					UpperCamelCase__       :List[str]							 =			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				(      __a = ""       )  ->     None:



					'''simple docstring'''






					print('''\nFor string = '''			, __a			, ''':'''       )
					print(
					    '''> can_string_be_rearranged_as_palindrome_counter()'''			, '''\tans ='''			, can_string_be_rearranged_as_palindrome_counter(__a       )			, '''\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(__a       )			, '''\ttime ='''			, timeit(
					        '''z.can_string_be_rearranged_as_palindrome(z.check_str)'''			, setup='''import __main__ as z'''			, )			, '''seconds'''			, )


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