






"""simple docstring"""
import gc
import unittest

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

from diffusers import PriorTransformer, UnCLIPPipeline, UnCLIPScheduler, UNetaDConditionModel, UNetaDModel
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import load_numpy, nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()



class 					UpperCamelCase__   (							a_       ,  unittest.TestCase):







    """simple docstring"""
    __UpperCAmelCase											=   UnCLIPPipeline
    __UpperCAmelCase											=   TEXT_TO_IMAGE_PARAMS - {
        """negative_prompt""",
        """height""",
        """width""",
        """negative_prompt_embeds""",
        """guidance_scale""",
        """prompt_embeds""",
        """cross_attention_kwargs""",
    }
    __UpperCAmelCase											=   TEXT_TO_IMAGE_BATCH_PARAMS
    __UpperCAmelCase											=   [
        """generator""",
        """return_dict""",
        """prior_num_inference_steps""",
        """decoder_num_inference_steps""",
        """super_res_num_inference_steps""",
    ]
    __UpperCAmelCase											=   False







    @property
    def 							a__ (		self   :  List[Any]   ):





           '''simple docstring'''

           return 3_2







    @property
    def 							a__ (		self   :  List[str]   ):





           '''simple docstring'''

           return 3_2







    @property
    def 							a__ (		self   :  Tuple   ):





           '''simple docstring'''

           return self.time_input_dim







    @property
    def 							a__ (		self   :  Dict   ):





           '''simple docstring'''

           return self.time_input_dim * 4







    @property
    def 							a__ (		self   :  str   ):





           '''simple docstring'''

           return 1_0_0







    @property
    def 							a__ (		self   :  List[Any]   ):





           '''simple docstring'''

           __magic_name__										=						CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'   )
           return tokenizer







    @property
    def 							a__ (		self   :  List[str]   ):





           '''simple docstring'''

           torch.manual_seed(0   )
           __magic_name__										=						CLIPTextConfig(
               bos_token_id=0							,						eos_token_id=2							,						hidden_size=self.text_embedder_hidden_size							,						projection_dim=self.text_embedder_hidden_size							,						intermediate_size=3_7							,						layer_norm_eps=1e-0_5							,						num_attention_heads=4							,						num_hidden_layers=5							,						pad_token_id=1							,						vocab_size=1_0_0_0							,						)
           return CLIPTextModelWithProjection(UpperCamelCase_   )







    @property
    def 							a__ (		self   :  str   ):





           '''simple docstring'''

           torch.manual_seed(0   )

           __magic_name__										=						{
               'num_attention_heads': 2,
               'attention_head_dim': 1_2,
               'embedding_dim': self.text_embedder_hidden_size,
               'num_layers': 1,
           }

           __magic_name__										=						PriorTransformer(**UpperCamelCase_   )
           return model







    @property
    def 							a__ (		self   :  Any   ):





           '''simple docstring'''

           torch.manual_seed(0   )

           __magic_name__										=						{
               'clip_embeddings_dim': self.text_embedder_hidden_size,
               'time_embed_dim': self.time_embed_dim,
               'cross_attention_dim': self.cross_attention_dim,
           }

           __magic_name__										=						UnCLIPTextProjModel(**UpperCamelCase_   )
           return model







    @property
    def 							a__ (		self   :  Dict   ):





           '''simple docstring'''

           torch.manual_seed(0   )

           __magic_name__										=						{
               'sample_size': 3_2,
               # RGB in channels
               'in_channels': 3,
               # Out channels is double in channels because predicts mean and variance
               'out_channels': 6,
               '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,
               'cross_attention_dim': self.cross_attention_dim,
               'attention_head_dim': 4,
               'resnet_time_scale_shift': 'scale_shift',
               'class_embed_type': 'identity',
           }

           __magic_name__										=						UNetaDConditionModel(**UpperCamelCase_   )
           return model







    @property
    def 							a__ (		self   :  str   ):





           '''simple docstring'''

           return {
               "sample_size": 6_4,
               "layers_per_block": 1,
               "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
               "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
               "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
               "in_channels": 6,
               "out_channels": 3,
           }







    @property
    def 							a__ (		self   :  int   ):





           '''simple docstring'''

           torch.manual_seed(0   )

           __magic_name__										=						UNetaDModel(**self.dummy_super_res_kwargs   )
           return model







    @property
    def 							a__ (		self   :  Union[str, Any]   ):





           '''simple docstring'''

           torch.manual_seed(1   )

           __magic_name__										=						UNetaDModel(**self.dummy_super_res_kwargs   )
           return model







    def 							a__ (		self   :  List[Any]   ):





           '''simple docstring'''

           __magic_name__										=						self.dummy_prior
           __magic_name__										=						self.dummy_decoder
           __magic_name__										=						self.dummy_text_proj
           __magic_name__										=						self.dummy_text_encoder
           __magic_name__										=						self.dummy_tokenizer
           __magic_name__										=						self.dummy_super_res_first
           __magic_name__										=						self.dummy_super_res_last

           __magic_name__										=						UnCLIPScheduler(
               variance_type='fixed_small_log'							,						prediction_type='sample'							,						num_train_timesteps=1_0_0_0							,						clip_sample_range=5.0							,						)

           __magic_name__										=						UnCLIPScheduler(
               variance_type='learned_range'							,						prediction_type='epsilon'							,						num_train_timesteps=1_0_0_0							,						)

           __magic_name__										=						UnCLIPScheduler(
               variance_type='fixed_small_log'							,						prediction_type='epsilon'							,						num_train_timesteps=1_0_0_0							,						)

           __magic_name__										=						{
               'prior': prior,
               'decoder': decoder,
               'text_proj': text_proj,
               'text_encoder': text_encoder,
               'tokenizer': tokenizer,
               'super_res_first': super_res_first,
               'super_res_last': super_res_last,
               'prior_scheduler': prior_scheduler,
               'decoder_scheduler': decoder_scheduler,
               'super_res_scheduler': super_res_scheduler,
           }

           return components







    def 							a__ (		self   :  Optional[Any]							,						UpperCamelCase_   :  str							,						UpperCamelCase_   :  Tuple=0   ):





           '''simple docstring'''

           if str(UpperCamelCase_   ).startswith('mps'   ):
                  __magic_name__										=						torch.manual_seed(UpperCamelCase_   )
           else:
                  __magic_name__										=						torch.Generator(device=UpperCamelCase_   ).manual_seed(UpperCamelCase_   )
           __magic_name__										=						{
               'prompt': 'horse',
               'generator': generator,
               'prior_num_inference_steps': 2,
               'decoder_num_inference_steps': 2,
               'super_res_num_inference_steps': 2,
               'output_type': 'numpy',
           }
           return inputs







    def 							a__ (		self   :  List[str]   ):





           '''simple docstring'''

           __magic_name__										=						'cpu'

           __magic_name__										=						self.get_dummy_components()

           __magic_name__										=						self.pipeline_class(**UpperCamelCase_   )
           __magic_name__										=						pipe.to(UpperCamelCase_   )

           pipe.set_progress_bar_config(disable=UpperCamelCase_   )

           __magic_name__										=						pipe(**self.get_dummy_inputs(UpperCamelCase_   )   )
           __magic_name__										=						output.images

           __magic_name__										=						pipe(
               **self.get_dummy_inputs(UpperCamelCase_   )							,						return_dict=UpperCamelCase_							,						)[0]

           __magic_name__										=						image[0, -3:, -3:, -1]
           __magic_name__										=						image_from_tuple[0, -3:, -3:, -1]

           assert image.shape == (1, 6_4, 6_4, 3)

           __magic_name__										=						np.array(
               [
                   0.9_997,
                   0.9_988,
                   0.0_028,
                   0.9_997,
                   0.9_984,
                   0.9_965,
                   0.0_029,
                   0.9_986,
                   0.0_025,
               ]   )

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







    def 							a__ (		self   :  Dict   ):





           '''simple docstring'''

           __magic_name__										=						torch.device('cpu'   )



           class 					UpperCamelCase__   :







               """simple docstring"""
               __UpperCAmelCase											=   1
           __magic_name__										=						self.get_dummy_components()

           __magic_name__										=						self.pipeline_class(**UpperCamelCase_   )
           __magic_name__										=						pipe.to(UpperCamelCase_   )

           __magic_name__										=						components['prior']
           __magic_name__										=						components['decoder']
           __magic_name__										=						components['super_res_first']
           __magic_name__										=						components['tokenizer']
           __magic_name__										=						components['text_encoder']

           __magic_name__										=						torch.Generator(device=UpperCamelCase_   ).manual_seed(0   )
           __magic_name__										=						prior.dtype
           __magic_name__										=						1

           __magic_name__										=						(batch_size, prior.config.embedding_dim)
           __magic_name__										=						pipe.prepare_latents(
               UpperCamelCase_							,						dtype=UpperCamelCase_							,						device=UpperCamelCase_							,						generator=UpperCamelCase_							,						latents=UpperCamelCase_							,						scheduler=DummyScheduler()   )
           __magic_name__										=						(batch_size, decoder.config.in_channels, decoder.config.sample_size, decoder.config.sample_size)
           __magic_name__										=						pipe.prepare_latents(
               UpperCamelCase_							,						dtype=UpperCamelCase_							,						device=UpperCamelCase_							,						generator=UpperCamelCase_							,						latents=UpperCamelCase_							,						scheduler=DummyScheduler()   )

           __magic_name__										=						(
               batch_size,
               super_res_first.config.in_channels // 2,
               super_res_first.config.sample_size,
               super_res_first.config.sample_size,
           )
           __magic_name__										=						pipe.prepare_latents(
               UpperCamelCase_							,						dtype=UpperCamelCase_							,						device=UpperCamelCase_							,						generator=UpperCamelCase_							,						latents=UpperCamelCase_							,						scheduler=DummyScheduler()   )

           pipe.set_progress_bar_config(disable=UpperCamelCase_   )

           __magic_name__										=						'this is a prompt example'

           __magic_name__										=						torch.Generator(device=UpperCamelCase_   ).manual_seed(0   )
           __magic_name__										=						pipe(
               [prompt]							,						generator=UpperCamelCase_							,						prior_num_inference_steps=2							,						decoder_num_inference_steps=2							,						super_res_num_inference_steps=2							,						prior_latents=UpperCamelCase_							,						decoder_latents=UpperCamelCase_							,						super_res_latents=UpperCamelCase_							,						output_type='np'							,						)
           __magic_name__										=						output.images

           __magic_name__										=						tokenizer(
               UpperCamelCase_							,						padding='max_length'							,						max_length=tokenizer.model_max_length							,						return_tensors='pt'							,						)
           __magic_name__										=						text_encoder(text_inputs.input_ids   )
           __magic_name__										=						text_inputs.attention_mask

           __magic_name__										=						torch.Generator(device=UpperCamelCase_   ).manual_seed(0   )
           __magic_name__										=						pipe(
               generator=UpperCamelCase_							,						prior_num_inference_steps=2							,						decoder_num_inference_steps=2							,						super_res_num_inference_steps=2							,						prior_latents=UpperCamelCase_							,						decoder_latents=UpperCamelCase_							,						super_res_latents=UpperCamelCase_							,						text_model_output=UpperCamelCase_							,						text_attention_mask=UpperCamelCase_							,						output_type='np'							,						)[0]

           # make sure passing text embeddings manually is identical
           assert np.abs(image - image_from_text   ).max() < 1e-4







    @skip_mps
    def 							a__ (		self   :  List[Any]   ):





           '''simple docstring'''

           __magic_name__										=						torch_device == 'cpu'

           self._test_attention_slicing_forward_pass(test_max_difference=UpperCamelCase_							,						expected_max_diff=0.01   )







    @skip_mps
    def 							a__ (		self   :  List[str]   ):





           '''simple docstring'''

           __magic_name__										=						torch_device == 'cpu'
           __magic_name__										=						True
           __magic_name__										=						[
               'prior_num_inference_steps',
               'decoder_num_inference_steps',
               'super_res_num_inference_steps',
           ]

           self._test_inference_batch_single_identical(
               test_max_difference=UpperCamelCase_							,						relax_max_difference=UpperCamelCase_							,						additional_params_copy_to_batched_inputs=UpperCamelCase_							,						)







    def 							a__ (		self   :  Optional[int]   ):





           '''simple docstring'''

           __magic_name__										=						[
               'prior_num_inference_steps',
               'decoder_num_inference_steps',
               'super_res_num_inference_steps',
           ]

           if torch_device == "mps":
                  # TODO: MPS errors with larger batch sizes
                  __magic_name__										=						[2, 3]
                  self._test_inference_batch_consistent(
                      batch_sizes=UpperCamelCase_							,						additional_params_copy_to_batched_inputs=UpperCamelCase_							,						)
           else:
                  self._test_inference_batch_consistent(
                      additional_params_copy_to_batched_inputs=UpperCamelCase_   )







    @skip_mps
    def 							a__ (		self   :  List[str]   ):





           '''simple docstring'''

           return super().test_dict_tuple_outputs_equivalent()







    @skip_mps
    def 							a__ (		self   :  Tuple   ):





           '''simple docstring'''

           return super().test_save_load_local()







    @skip_mps
    def 							a__ (		self   :  Optional[int]   ):





           '''simple docstring'''

           return super().test_save_load_optional_components()



@nightly
class 					UpperCamelCase__   (							unittest.TestCase):







    """simple docstring"""







    def 							a__ (		self   :  Tuple   ):





           '''simple docstring'''

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







    def 							a__ (		self   :  Union[str, Any]   ):





           '''simple docstring'''

           __magic_name__										=						load_numpy(
               'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
               '/unclip/karlo_v1_alpha_horse_cpu.npy'   )

           __magic_name__										=						UnCLIPPipeline.from_pretrained('kakaobrain/karlo-v1-alpha'   )
           pipeline.set_progress_bar_config(disable=UpperCamelCase_   )

           __magic_name__										=						torch.manual_seed(0   )
           __magic_name__										=						pipeline(
               'horse'							,						num_images_per_prompt=1							,						generator=UpperCamelCase_							,						output_type='np'							,						)

           __magic_name__										=						output.images[0]

           assert image.shape == (2_5_6, 2_5_6, 3)
           assert np.abs(expected_image - image   ).max() < 1e-1



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







    """simple docstring"""







    def 							a__ (		self   :  List[str]   ):





           '''simple docstring'''

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







    def 							a__ (		self   :  int   ):





           '''simple docstring'''

           __magic_name__										=						load_numpy(
               'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
               '/unclip/karlo_v1_alpha_horse_fp16.npy'   )

           __magic_name__										=						UnCLIPPipeline.from_pretrained('kakaobrain/karlo-v1-alpha'							,						torch_dtype=torch.floataa   )
           __magic_name__										=						pipeline.to(UpperCamelCase_   )
           pipeline.set_progress_bar_config(disable=UpperCamelCase_   )

           __magic_name__										=						torch.Generator(device='cpu'   ).manual_seed(0   )
           __magic_name__										=						pipeline(
               'horse'							,						generator=UpperCamelCase_							,						output_type='np'							,						)

           __magic_name__										=						output.images[0]

           assert image.shape == (2_5_6, 2_5_6, 3)

           assert_mean_pixel_difference(UpperCamelCase_							,						UpperCamelCase_   )







    def 							a__ (		self   :  str   ):





           '''simple docstring'''

           torch.cuda.empty_cache()
           torch.cuda.reset_max_memory_allocated()
           torch.cuda.reset_peak_memory_stats()

           __magic_name__										=						UnCLIPPipeline.from_pretrained('kakaobrain/karlo-v1-alpha'							,						torch_dtype=torch.floataa   )
           __magic_name__										=						pipe.to(UpperCamelCase_   )
           pipe.set_progress_bar_config(disable=UpperCamelCase_   )
           pipe.enable_attention_slicing()
           pipe.enable_sequential_cpu_offload()

           __magic_name__										=						pipe(
               'horse'							,						num_images_per_prompt=1							,						prior_num_inference_steps=2							,						decoder_num_inference_steps=2							,						super_res_num_inference_steps=2							,						output_type='np'							,						)

           __magic_name__										=						torch.cuda.max_memory_allocated()
           # make sure that less than 7 GB is allocated
           assert mem_bytes < 7 * 1_0**9







"""simple docstring"""
def        A	(							__snake_case:   Dict   ,    __snake_case:   Tuple     )						->		int:

       """simple docstring"""





       sequence.append(__snake_case     )

       __magic_name__										=						0
       while sequence[index] != target:
              index += 1

       sequence.pop()

       if index == len(__snake_case     ):
              return None

       return index


if __name__ == "__main__":
 snake_case   :   Dict    		=		input("""Enter numbers separated by comma:\n""").strip()
 snake_case   :   List[str]    		=		[int(item) for item in user_input.split(""",""")]

 snake_case   :   Union[str, Any]    		=		input("""Enter a single number to be found in the list:\n""")
 snake_case   :   str    		=		int(target_input)
 snake_case   :   Any    		=		sentinel_linear_search(sequence, target)
 if result is not None:
  print(f"""{target} found at positions: {result}""")
 else:
  print("""Not found""")