






import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import (
    DiffusionPipeline,
    UnCLIPImageVariationPipeline,
    UnCLIPScheduler,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, load_image, require_torch_gpu, skip_mps

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()







class  _lowercase   (   _A						,				unittest.TestCase						):
      _a							:						Optional[Any]										=							UnCLIPImageVariationPipeline
      _a							:						Optional[int]										=							IMAGE_VARIATION_PARAMS - {'height', 'width', 'guidance_scale'}
      _a							:						Optional[Any]										=							IMAGE_VARIATION_BATCH_PARAMS

      _a							:						str										=							[
          'generator',
          'return_dict',
          'decoder_num_inference_steps',
          'super_res_num_inference_steps',
      ]
      _a							:						Any										=							False
      @property
      def 						lowercase__					(     self   ):
       return 3_2
      @property
      def 						lowercase__					(     self   ):
       return 3_2
      @property
      def 						lowercase__					(     self   ):
       return self.time_input_dim
      @property
      def 						lowercase__					(     self   ):
       return self.time_input_dim * 4
      @property
      def 						lowercase__					(     self   ):
       return 1_0_0
      @property
      def 						lowercase__					(     self   ):
       snake_case__  :    Dict							       =CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""   )
       return tokenizer
      @property
      def 						lowercase__					(     self   ):
       torch.manual_seed(0   )
       snake_case__  :    int							       =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-05				,			num_attention_heads=4				,			num_hidden_layers=5				,			pad_token_id=1				,			vocab_size=1_0_0_0				,			)
       return CLIPTextModelWithProjection(a   )
      @property
      def 						lowercase__					(     self   ):
       torch.manual_seed(0   )
       snake_case__  :    Optional[int]							       =CLIPVisionConfig(
           hidden_size=self.text_embedder_hidden_size				,			projection_dim=self.text_embedder_hidden_size				,			num_hidden_layers=5				,			num_attention_heads=4				,			image_size=3_2				,			intermediate_size=3_7				,			patch_size=1				,			)
       return CLIPVisionModelWithProjection(a   )
      @property
      def 						lowercase__					(     self   ):
       torch.manual_seed(0   )

       snake_case__  :    int							       ={
           """clip_embeddings_dim""": self.text_embedder_hidden_size,
           """time_embed_dim""": self.time_embed_dim,
           """cross_attention_dim""": self.cross_attention_dim,
       }

       snake_case__  :    Optional[int]							       =UnCLIPTextProjModel(**a   )
       return model
      @property
      def 						lowercase__					(     self   ):
       torch.manual_seed(0   )

       snake_case__  :    List[str]							       ={
           """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""",
       }

       snake_case__  :    List[str]							       =UNetaDConditionModel(**a   )
       return model
      @property
      def 						lowercase__					(     self   ):
       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 						lowercase__					(     self   ):
       torch.manual_seed(0   )

       snake_case__  :    Union[str, Any]							       =UNetaDModel(**self.dummy_super_res_kwargs   )
       return model
      @property
      def 						lowercase__					(     self   ):
       # seeded differently to get different unet than `self.dummy_super_res_first`
       torch.manual_seed(1   )

       snake_case__  :    int							       =UNetaDModel(**self.dummy_super_res_kwargs   )
       return model
      def 						lowercase__					(     self   ):
       snake_case__  :    Union[str, Any]							       =self.dummy_decoder
       snake_case__  :    Any							       =self.dummy_text_proj
       snake_case__  :    Optional[int]							       =self.dummy_text_encoder
       snake_case__  :    Optional[Any]							       =self.dummy_tokenizer
       snake_case__  :    List[str]							       =self.dummy_super_res_first
       snake_case__  :    str							       =self.dummy_super_res_last

       snake_case__  :    List[Any]							       =UnCLIPScheduler(
           variance_type="""learned_range"""				,			prediction_type="""epsilon"""				,			num_train_timesteps=1_0_0_0				,			)

       snake_case__  :    Any							       =UnCLIPScheduler(
           variance_type="""fixed_small_log"""				,			prediction_type="""epsilon"""				,			num_train_timesteps=1_0_0_0				,			)

       snake_case__  :    str							       =CLIPImageProcessor(crop_size=3_2				,			size=3_2   )

       snake_case__  :    List[Any]							       =self.dummy_image_encoder

       return {
           "decoder": decoder,
           "text_encoder": text_encoder,
           "tokenizer": tokenizer,
           "text_proj": text_proj,
           "feature_extractor": feature_extractor,
           "image_encoder": image_encoder,
           "super_res_first": super_res_first,
           "super_res_last": super_res_last,
           "decoder_scheduler": decoder_scheduler,
           "super_res_scheduler": super_res_scheduler,
       }
      def 						lowercase__					(     self				,			a				,			a=0				,			a=True   ):
       snake_case__  :    str							       =floats_tensor((1, 3, 3_2, 3_2)				,			rng=random.Random(a   )   ).to(a   )
       if str(a   ).startswith("""mps"""   ):
        snake_case__  :    str							       =torch.manual_seed(a   )
       else:
        snake_case__  :    List[Any]							       =torch.Generator(device=a   ).manual_seed(a   )

       if pil_image:
        snake_case__  :    Optional[int]							       =input_image * 0.5 + 0.5
        snake_case__  :    Tuple							       =input_image.clamp(0				,			1   )
        snake_case__  :    Union[str, Any]							       =input_image.cpu().permute(0				,			2				,			3				,			1   ).float().numpy()
        snake_case__  :    Tuple							       =DiffusionPipeline.numpy_to_pil(a   )[0]

       return {
           "image": input_image,
           "generator": generator,
           "decoder_num_inference_steps": 2,
           "super_res_num_inference_steps": 2,
           "output_type": "np",
       }
      def 						lowercase__					(     self   ):
       snake_case__  :    Union[str, Any]							       ="""cpu"""

       snake_case__  :    Dict							       =self.get_dummy_components()

       snake_case__  :    Tuple							       =self.pipeline_class(**a   )
       snake_case__  :    Optional[Any]							       =pipe.to(a   )

       pipe.set_progress_bar_config(disable=a   )

       snake_case__  :    Optional[int]							       =self.get_dummy_inputs(a				,			pil_image=a   )

       snake_case__  :    List[str]							       =pipe(**a   )
       snake_case__  :    List[str]							       =output.images

       snake_case__  :    Any							       =self.get_dummy_inputs(a				,			pil_image=a   )

       snake_case__  :    List[Any]							       =pipe(
           **a				,			return_dict=a				,			)[0]

       snake_case__  :    Union[str, Any]							       =image[0, -3:, -3:, -1]
       snake_case__  :    Optional[int]							       =image_from_tuple[0, -3:, -3:, -1]

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

       snake_case__  :    Optional[Any]							       =np.array(
           [
               0.9997,
               0.0002,
               0.9997,
               0.9997,
               0.9969,
               0.0023,
               0.9997,
               0.9969,
               0.9970,
           ]   )

       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 						lowercase__					(     self   ):
       snake_case__  :    Dict							       ="""cpu"""

       snake_case__  :    int							       =self.get_dummy_components()

       snake_case__  :    Any							       =self.pipeline_class(**a   )
       snake_case__  :    Tuple							       =pipe.to(a   )

       pipe.set_progress_bar_config(disable=a   )

       snake_case__  :    int							       =self.get_dummy_inputs(a				,			pil_image=a   )

       snake_case__  :    Any							       =pipe(**a   )
       snake_case__  :    Optional[int]							       =output.images

       snake_case__  :    int							       =self.get_dummy_inputs(a				,			pil_image=a   )

       snake_case__  :    List[str]							       =pipe(
           **a				,			return_dict=a				,			)[0]

       snake_case__  :    List[str]							       =image[0, -3:, -3:, -1]
       snake_case__  :    List[Any]							       =image_from_tuple[0, -3:, -3:, -1]

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

       snake_case__  :    str							       =np.array([0.9997, 0.0003, 0.9997, 0.9997, 0.9970, 0.0024, 0.9997, 0.9971, 0.9971]   )

       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 						lowercase__					(     self   ):
       snake_case__  :    List[str]							       ="""cpu"""

       snake_case__  :    Dict							       =self.get_dummy_components()

       snake_case__  :    Tuple							       =self.pipeline_class(**a   )
       snake_case__  :    List[Any]							       =pipe.to(a   )

       pipe.set_progress_bar_config(disable=a   )

       snake_case__  :    Tuple							       =self.get_dummy_inputs(a				,			pil_image=a   )
       snake_case__  :    Any							       =[
           pipeline_inputs["""image"""],
           pipeline_inputs["""image"""],
       ]

       snake_case__  :    Tuple							       =pipe(**a   )
       snake_case__  :    str							       =output.images

       snake_case__  :    Tuple							       =self.get_dummy_inputs(a				,			pil_image=a   )
       snake_case__  :    str							       =[
           tuple_pipeline_inputs["""image"""],
           tuple_pipeline_inputs["""image"""],
       ]

       snake_case__  :    Union[str, Any]							       =pipe(
           **a				,			return_dict=a				,			)[0]

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

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

       snake_case__  :    int							       =np.array(
           [
               0.9997,
               0.9989,
               0.0008,
               0.0021,
               0.9960,
               0.0018,
               0.0014,
               0.0002,
               0.9933,
           ]   )

       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 						lowercase__					(     self   ):
       snake_case__  :    Optional[int]							       =torch.device("""cpu"""   )







       class  _lowercase   :
             _a							:						Tuple										=							1




       snake_case__  :    Optional[Any]							       =self.get_dummy_components()

       snake_case__  :    List[str]							       =self.pipeline_class(**a   )
       snake_case__  :    int							       =pipe.to(a   )

       pipe.set_progress_bar_config(disable=a   )

       snake_case__  :    List[Any]							       =torch.Generator(device=a   ).manual_seed(0   )
       snake_case__  :    List[Any]							       =pipe.decoder.dtype
       snake_case__  :    str							       =1

       snake_case__  :    Dict							       =(
           batch_size,
           pipe.decoder.config.in_channels,
           pipe.decoder.config.sample_size,
           pipe.decoder.config.sample_size,
       )
       snake_case__  :    List[Any]							       =pipe.prepare_latents(
           a				,			dtype=a				,			device=a				,			generator=a				,			latents=a				,			scheduler=DummyScheduler()   )

       snake_case__  :    Optional[int]							       =(
           batch_size,
           pipe.super_res_first.config.in_channels // 2,
           pipe.super_res_first.config.sample_size,
           pipe.super_res_first.config.sample_size,
       )
       snake_case__  :    Dict							       =pipe.prepare_latents(
           a				,			dtype=a				,			device=a				,			generator=a				,			latents=a				,			scheduler=DummyScheduler()   )

       snake_case__  :    Union[str, Any]							       =self.get_dummy_inputs(a				,			pil_image=a   )

       snake_case__  :    List[str]							       =pipe(
           **a				,			decoder_latents=a				,			super_res_latents=a   ).images

       snake_case__  :    Any							       =self.get_dummy_inputs(a				,			pil_image=a   )
       # Don't pass image, instead pass embedding
       snake_case__  :    Optional[Any]							       =pipeline_inputs.pop("""image"""   )
       snake_case__  :    Optional[int]							       =pipe.image_encoder(a   ).image_embeds

       snake_case__  :    Dict							       =pipe(
           **a				,			decoder_latents=a				,			super_res_latents=a				,			image_embeddings=a				,			).images

       # make sure passing text embeddings manually is identical
       assert np.abs(img_out_a - img_out_a   ).max() < 1e-4
      @skip_mps
      def 						lowercase__					(     self   ):
       snake_case__  :    List[str]							       =torch_device == """cpu"""

       # Check is relaxed because there is not a torch 2.0 sliced attention added kv processor
       snake_case__  :    Tuple							       =1e-2

       self._test_attention_slicing_forward_pass(
           test_max_difference=a				,			expected_max_diff=a   )
      @skip_mps
      def 						lowercase__					(     self   ):
       snake_case__  :    List[Any]							       =torch_device == """cpu"""
       snake_case__  :    List[Any]							       =True
       snake_case__  :    List[Any]							       =[
           """decoder_num_inference_steps""",
           """super_res_num_inference_steps""",
       ]

       self._test_inference_batch_single_identical(
           test_max_difference=a				,			relax_max_difference=a				,			additional_params_copy_to_batched_inputs=a				,			)
      def 						lowercase__					(     self   ):
       snake_case__  :    Dict							       =[
           """decoder_num_inference_steps""",
           """super_res_num_inference_steps""",
       ]

       if torch_device == "mps":
        # TODO: MPS errors with larger batch sizes
        snake_case__  :    List[Any]							       =[2, 3]
        self._test_inference_batch_consistent(
            batch_sizes=a				,			additional_params_copy_to_batched_inputs=a				,			)
       else:
        self._test_inference_batch_consistent(
            additional_params_copy_to_batched_inputs=a   )
      @skip_mps
      def 						lowercase__					(     self   ):
       return super().test_dict_tuple_outputs_equivalent()
      @skip_mps
      def 						lowercase__					(     self   ):
       return super().test_save_load_local()



      @skip_mps
      def 						lowercase__					(     self   ):
       return super().test_save_load_optional_components()







@slow
@require_torch_gpu
class  _lowercase   (   unittest.TestCase						):
      def 						lowercase__					(     self   ):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()



      def 						lowercase__					(     self   ):
       snake_case__  :    str							       =load_image(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/unclip/cat.png"""   )
       snake_case__  :    Union[str, Any]							       =load_numpy(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
           """/unclip/karlo_v1_alpha_cat_variation_fp16.npy"""   )

       snake_case__  :    List[Any]							       =UnCLIPImageVariationPipeline.from_pretrained(
           """kakaobrain/karlo-v1-alpha-image-variations"""				,			torch_dtype=torch.floataa   )
       snake_case__  :    Optional[int]							       =pipeline.to(a   )
       pipeline.set_progress_bar_config(disable=a   )

       snake_case__  :    Optional[Any]							       =torch.Generator(device="""cpu"""   ).manual_seed(0   )
       snake_case__  :    Tuple							       =pipeline(
           a				,			generator=a				,			output_type="""np"""				,			)

       snake_case__  :    Union[str, Any]							       =output.images[0]

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

       assert_mean_pixel_difference(a				,			a				,			1_5   )













from string import ascii_uppercase

__lowerCamelCase	:		List[Any]										=   {str(ord(c) - 55): c for c in ascii_uppercase}







def 			A__							(      _a  :					int		,  _a  :					int	):





 '''simple docstring'''







 if isinstance(_a		,  _a	):
  raise TypeError("""int() can't convert non-string with explicit base"""	)
 if num < 0:
  raise ValueError("""parameter must be positive int"""	)
 if isinstance(_a		,  _a	):
  raise TypeError("""'str' object cannot be interpreted as an integer"""	)
 if isinstance(_a		,  _a	):
  raise TypeError("""'float' object cannot be interpreted as an integer"""	)
 if base in (0, 1):
  raise ValueError("""base must be >= 2"""	)
 if base > 36:
  raise ValueError("""base must be <= 36"""	)
 snake_case__  :    Union[str, Any]							       =""""""
 snake_case__  :    List[str]							       =0
 snake_case__  :    List[Any]							       =0
 while div != 1:
  snake_case__       ,   snake_case__  :    Union[str, Any]							       =divmod(_a		,  _a	)
  if base >= 11 and 9 < mod < 36:
   snake_case__  :    Dict							       =ALPHABET_VALUES[str(_a	)]
  else:
   snake_case__  :    Optional[Any]							       =str(_a	)
  new_value += actual_value
  snake_case__  :    Dict							       =num // base
  snake_case__  :    Tuple							       =div
  if div == 0:
   return str(new_value[::-1]	)
  elif div == 1:
   new_value += str(_a	)
   return str(new_value[::-1]	)

 return new_value[::-1]


if __name__ == "__main__":
       import doctest

       doctest.testmod()

       for base in range(2, 37):
              for num in range(10_00):
                     assert int(decimal_to_any(num, base), base) == num, (
                         num,
                         base,
                         decimal_to_any(num, base),
                         int(decimal_to_any(num, base), base),
                     )





