


'''simple docstring'''







import gc
import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()
class 	UpperCamelCase__					( SCREAMING_SNAKE_CASE_    ,					SCREAMING_SNAKE_CASE_    ,					unittest.TestCase	):



     """simple docstring"""






     __magic_name__    			=    StableDiffusionXLImgaImgPipeline
     __magic_name__    			=    TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"}
     __magic_name__    			=    PipelineTesterMixin.required_optional_params - {"latents"}
     __magic_name__    			=    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
     __magic_name__    			=    IMAGE_TO_IMAGE_IMAGE_PARAMS
     __magic_name__    			=    IMAGE_TO_IMAGE_IMAGE_PARAMS







     def a	( self   ):

            '''simple docstring'''

            torch.manual_seed(0   )
            _lowerCAmelCase    :							Optional[Any]   			=       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')      ,	attention_head_dim=(2, 4)      ,	use_linear_projection=snake_case__      ,	addition_embed_type='text_time'      ,	addition_time_embed_dim=8      ,	transformer_layers_per_block=(1, 2)      ,	projection_class_embeddings_input_dim=80      ,	cross_attention_dim=64      ,	)
            _lowerCAmelCase    :							Optional[int]   			=       EulerDiscreteScheduler(
                beta_start=0.0_0085      ,	beta_end=0.012      ,	steps_offset=1      ,	beta_schedule='scaled_linear'      ,	timestep_spacing='leading'      ,	)
            torch.manual_seed(0   )
            _lowerCAmelCase    :							int   			=       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    :							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=32      ,	)
            _lowerCAmelCase    :							Tuple   			=       CLIPTextModel(snake_case__   )
            _lowerCAmelCase    :							Optional[int]   			=       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      ,	local_files_only=snake_case__   )

            _lowerCAmelCase    :							int   			=       CLIPTextModelWithProjection(snake_case__   )
            _lowerCAmelCase    :							Tuple   			=       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      ,	local_files_only=snake_case__   )

            _lowerCAmelCase    :							Dict   			=       {
                'unet': unet,
                'scheduler': scheduler,
                'vae': vae,
                'text_encoder': text_encoder,
                'tokenizer': tokenizer,
                'text_encoder_2': text_encoder_a,
                'tokenizer_2': tokenizer_a,
                # "safety_checker": None,
                # "feature_extractor": None,
            }
            return components







     def a	( self      ,	snake_case__      ,	snake_case__=0   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Optional[Any]   			=       floats_tensor((1, 3, 32, 32)      ,	rng=random.Random(snake_case__   )   ).to(snake_case__   )
            _lowerCAmelCase    :							Dict   			=       image / 2 + 0.5
            if str(snake_case__   ).startswith('mps'   ):
                   _lowerCAmelCase    :							int   			=       torch.manual_seed(snake_case__   )
            else:
                   _lowerCAmelCase    :							List[str]   			=       torch.Generator(device=snake_case__   ).manual_seed(snake_case__   )
            _lowerCAmelCase    :							Optional[Any]   			=       {
                'prompt': 'A painting of a squirrel eating a burger',
                'image': image,
                'generator': generator,
                'num_inference_steps': 2,
                'guidance_scale': 5.0,
                'output_type': 'numpy',
                'strength': 0.75,
            }
            return inputs







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Dict   			=       'cpu'  # ensure determinism for the device-dependent torch.Generator
            _lowerCAmelCase    :							Tuple   			=       self.get_dummy_components()
            _lowerCAmelCase    :							Dict   			=       StableDiffusionXLImgaImgPipeline(**snake_case__   )
            _lowerCAmelCase    :							Optional[int]   			=       sd_pipe.to(snake_case__   )
            sd_pipe.set_progress_bar_config(disable=snake_case__   )

            _lowerCAmelCase    :							Optional[Any]   			=       self.get_dummy_inputs(snake_case__   )
            _lowerCAmelCase    :							str   			=       sd_pipe(**snake_case__   ).images
            _lowerCAmelCase    :							Any   			=       image[0, -3:, -3:, -1]

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

            _lowerCAmelCase    :							str   			=       np.array([0.4656, 0.4840, 0.4439, 0.6698, 0.5574, 0.4524, 0.5799, 0.5943, 0.5165]   )

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







     def a	( self   ):

            '''simple docstring'''

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







     def a	( self   ):

            '''simple docstring'''

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







     def a	( self   ):

            '''simple docstring'''

            pass







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Dict   			=       self.get_dummy_components()
            _lowerCAmelCase    :							Any   			=       StableDiffusionXLImgaImgPipeline(**snake_case__   )
            _lowerCAmelCase    :							int   			=       sd_pipe.to(snake_case__   )
            _lowerCAmelCase    :							Union[str, Any]   			=       sd_pipe.to(snake_case__   )
            sd_pipe.set_progress_bar_config(disable=snake_case__   )

            # forward without prompt embeds
            _lowerCAmelCase    :							Optional[int]   			=       self.get_dummy_inputs(snake_case__   )
            _lowerCAmelCase    :							Optional[int]   			=       3 * ['this is a negative prompt']
            _lowerCAmelCase    :							List[Any]   			=       negative_prompt
            _lowerCAmelCase    :							int   			=       3 * [inputs['prompt']]

            _lowerCAmelCase    :							str   			=       sd_pipe(**snake_case__   )
            _lowerCAmelCase    :							Optional[Any]   			=       output.images[0, -3:, -3:, -1]

            # forward with prompt embeds
            _lowerCAmelCase    :							str   			=       self.get_dummy_inputs(snake_case__   )
            _lowerCAmelCase    :							Optional[Any]   			=       3 * ['this is a negative prompt']
            _lowerCAmelCase    :							List[Any]   			=       3 * [inputs.pop('prompt'   )]

            (
                (
                _lowerCAmelCase
            )			,     (
                _lowerCAmelCase
            )			,     (
                _lowerCAmelCase
            )			,     (
                _lowerCAmelCase
            )			,     
            )    :							Optional[Any]   			=       sd_pipe.encode_prompt(snake_case__      ,	negative_prompt=snake_case__   )

            _lowerCAmelCase    :							Tuple   			=       sd_pipe(
                **snake_case__      ,	prompt_embeds=snake_case__      ,	negative_prompt_embeds=snake_case__      ,	pooled_prompt_embeds=snake_case__      ,	negative_pooled_prompt_embeds=snake_case__      ,	)
            _lowerCAmelCase    :							int   			=       output.images[0, -3:, -3:, -1]

            # make sure that it's equal
            assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()   ).max() < 1E-4
@slow
@require_torch_gpu
class 	UpperCamelCase__					( unittest.TestCase	):



     """simple docstring"""






     def a	( self   ):

            '''simple docstring'''

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







     def a	( self      ,	snake_case__      ,	snake_case__="cpu"      ,	snake_case__=torch.floataa      ,	snake_case__=0   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[Any]   			=       torch.Generator(device=snake_case__   ).manual_seed(snake_case__   )
            _lowerCAmelCase    :							Dict   			=       np.random.RandomState(snake_case__   ).standard_normal((1, 4, 64, 64)   )
            _lowerCAmelCase    :							str   			=       torch.from_numpy(snake_case__   ).to(device=snake_case__      ,	dtype=snake_case__   )
            _lowerCAmelCase    :							Optional[int]   			=       {
                'prompt': 'a photograph of an astronaut riding a horse',
                'latents': latents,
                'generator': generator,
                'num_inference_steps': 3,
                'guidance_scale': 7.5,
                'output_type': 'numpy',
            }
            return inputs







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Tuple   			=       DiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-base'   )
            pipe.to(snake_case__   )
            pipe.set_progress_bar_config(disable=snake_case__   )

            _lowerCAmelCase    :							Optional[Any]   			=       self.get_inputs(snake_case__   )
            _lowerCAmelCase    :							Dict   			=       pipe(**snake_case__   ).images
            _lowerCAmelCase    :							str   			=       image[0, -3:, -3:, -1].flatten()

            assert image.shape == (1, 512, 512, 3)
            _lowerCAmelCase    :							Tuple   			=       np.array([0.4_9493, 0.4_7896, 0.4_0798, 0.5_4214, 0.5_3212, 0.4_8202, 0.4_7656, 0.4_6329, 0.4_8506]   )
            assert np.abs(image_slice - expected_slice   ).max() < 7E-3





'''simple docstring'''







from collections import Counter
from timeit import timeit






def 			lowercase				(_A = ""   ,						):







       """simple docstring"""







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






def 			lowercase				(_A = ""					):







       """simple docstring"""







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

       for character in lower_case_input_str:
              _lowerCAmelCase    :							Union[str, Any]   			=       character_freq_dict.get(_A   ,						0					) + 1
       _lowerCAmelCase    :							List[Any]   			=       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 			lowercase				(_A = ""					):







       """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__":
       lowerCAmelCase    :     Tuple					=						input(
           """Enter string to determine if it can be rearranged as a palindrome or not: """
       ).strip()
       benchmark(check_str)
       lowerCAmelCase    :     Optional[Any]					=						can_string_be_rearranged_as_palindrome_counter(check_str)
       print(F'''{check_str} can {"" if status else "not "}be rearranged as a palindrome''')

