import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()
class SCREAMING_SNAKE_CASE_		(      __lowerCAmelCase  ,     __lowerCAmelCase  ,     __lowerCAmelCase  ,     unittest.TestCase		):
   __lowerCAmelCase           =				StableUnCLIPPipeline
   __lowerCAmelCase           =				TEXT_TO_IMAGE_PARAMS
   __lowerCAmelCase           =				TEXT_TO_IMAGE_BATCH_PARAMS
   __lowerCAmelCase           =				TEXT_TO_IMAGE_IMAGE_PARAMS
   __lowerCAmelCase           =				TEXT_TO_IMAGE_IMAGE_PARAMS

   # TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
   __lowerCAmelCase           =				False







   def 						lowerCamelCase_	(     self						:						int				):





    """simple docstring"""


    UpperCamelCase			  =      32
    UpperCamelCase			  =      embedder_hidden_size

    # prior components

    torch.manual_seed(0				)
    UpperCamelCase			  =      CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)

    torch.manual_seed(0				)
    UpperCamelCase			  =      CLIPTextModelWithProjection(
        CLIPTextConfig(
            bos_token_id=0   ,   eos_token_id=2   ,   hidden_size=lowerCamelCase_   ,   projection_dim=lowerCamelCase_   ,   intermediate_size=37   ,   layer_norm_eps=1E-05   ,   num_attention_heads=4   ,   num_hidden_layers=5   ,   pad_token_id=1   ,   vocab_size=1000   ,   )				)

    torch.manual_seed(0				)
    UpperCamelCase			  =      PriorTransformer(
        num_attention_heads=2   ,   attention_head_dim=12   ,   embedding_dim=lowerCamelCase_   ,   num_layers=1   ,   )

    torch.manual_seed(0				)
    UpperCamelCase			  =      DDPMScheduler(
        variance_type="""fixed_small_log"""   ,   prediction_type="""sample"""   ,   num_train_timesteps=1000   ,   clip_sample=lowerCamelCase_   ,   clip_sample_range=5.0   ,   beta_schedule="""squaredcos_cap_v2"""   ,   )

    # regular denoising components

    torch.manual_seed(0				)
    UpperCamelCase			  =      StableUnCLIPImageNormalizer(embedding_dim=lowerCamelCase_				)
    UpperCamelCase			  =      DDPMScheduler(beta_schedule="""squaredcos_cap_v2"""				)

    torch.manual_seed(0				)
    UpperCamelCase			  =      CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)

    torch.manual_seed(0				)
    UpperCamelCase			  =      CLIPTextModel(
        CLIPTextConfig(
            bos_token_id=0   ,   eos_token_id=2   ,   hidden_size=lowerCamelCase_   ,   projection_dim=32   ,   intermediate_size=37   ,   layer_norm_eps=1E-05   ,   num_attention_heads=4   ,   num_hidden_layers=5   ,   pad_token_id=1   ,   vocab_size=1000   ,   )				)

    torch.manual_seed(0				)
    UpperCamelCase			  =      UNetaDConditionModel(
        sample_size=32   ,   in_channels=4   ,   out_channels=4   ,   down_block_types=("""CrossAttnDownBlock2D""", """DownBlock2D""")   ,   up_block_types=("""UpBlock2D""", """CrossAttnUpBlock2D""")   ,   block_out_channels=(32, 64)   ,   attention_head_dim=(2, 4)   ,   class_embed_type="""projection"""   ,   projection_class_embeddings_input_dim=embedder_projection_dim * 2   ,   cross_attention_dim=lowerCamelCase_   ,   layers_per_block=1   ,   upcast_attention=lowerCamelCase_   ,   use_linear_projection=lowerCamelCase_   ,   )

    torch.manual_seed(0				)
    UpperCamelCase			  =      DDIMScheduler(
        beta_schedule="""scaled_linear"""   ,   beta_start=0.0_0_0_8_5   ,   beta_end=0.0_1_2   ,   prediction_type="""v_prediction"""   ,   set_alpha_to_one=lowerCamelCase_   ,   steps_offset=1   ,   )

    torch.manual_seed(0				)
    UpperCamelCase			  =      AutoencoderKL()

    UpperCamelCase			  =      {
        # prior components
        """prior_tokenizer""": prior_tokenizer,
        """prior_text_encoder""": prior_text_encoder,
        """prior""": prior,
        """prior_scheduler""": prior_scheduler,
        # image noising components
        """image_normalizer""": image_normalizer,
        """image_noising_scheduler""": image_noising_scheduler,
        # regular denoising components
        """tokenizer""": tokenizer,
        """text_encoder""": text_encoder,
        """unet""": unet,
        """scheduler""": scheduler,
        """vae""": vae,
    }

    return components







   def 						lowerCamelCase_	(     self						:						Dict   ,   lowerCamelCase_						:						Tuple   ,   lowerCamelCase_						:						Tuple=0				):





    """simple docstring"""


    if str(lowerCamelCase_				).startswith("""mps"""				):
     UpperCamelCase			  =      torch.manual_seed(lowerCamelCase_				)
    else:
     UpperCamelCase			  =      torch.Generator(device=lowerCamelCase_				).manual_seed(lowerCamelCase_				)
    UpperCamelCase			  =      {
        """prompt""": """A painting of a squirrel eating a burger""",
        """generator""": generator,
        """num_inference_steps""": 2,
        """prior_num_inference_steps""": 2,
        """output_type""": """numpy""",
    }
    return inputs







   def 						lowerCamelCase_	(     self						:						Optional[int]				):





    """simple docstring"""


    UpperCamelCase			  =      torch_device == """cpu"""

    self._test_attention_slicing_forward_pass(test_max_difference=lowerCamelCase_				)







   def 						lowerCamelCase_	(     self						:						List[str]				):





    """simple docstring"""


    UpperCamelCase			  =      torch_device in ["""cpu""", """mps"""]

    self._test_inference_batch_single_identical(test_max_difference=lowerCamelCase_				)





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







   def 						lowerCamelCase_	(     self						:						Optional[Any]				):





    """simple docstring"""


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







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





    """simple docstring"""


    UpperCamelCase			  =      load_numpy(
        """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy"""				)

    UpperCamelCase			  =      StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""   ,   torch_dtype=torch.floataa				)
    pipe.to(lowerCamelCase_				)
    pipe.set_progress_bar_config(disable=lowerCamelCase_				)
    # stable unclip will oom when integration tests are run on a V100,
    # so turn on memory savings
    pipe.enable_attention_slicing()
    pipe.enable_sequential_cpu_offload()

    UpperCamelCase			  =      torch.Generator(device="""cpu"""				).manual_seed(0				)
    UpperCamelCase			  =      pipe("""anime turle"""   ,   generator=lowerCamelCase_   ,   output_type="""np"""				)

    UpperCamelCase			  =      output.images[0]

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

    assert_mean_pixel_difference(lowerCamelCase_   ,   lowerCamelCase_				)







   def 						lowerCamelCase_	(     self						:						int				):





    """simple docstring"""


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

    UpperCamelCase			  =      StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""   ,   torch_dtype=torch.floataa				)
    UpperCamelCase			  =      pipe.to(lowerCamelCase_				)
    pipe.set_progress_bar_config(disable=lowerCamelCase_				)
    pipe.enable_attention_slicing()
    pipe.enable_sequential_cpu_offload()

    UpperCamelCase			  =      pipe(
        """anime turtle"""   ,   prior_num_inference_steps=2   ,   num_inference_steps=2   ,   output_type="""np"""   ,   )

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

def 			lowercase(	UpperCamelCase_							,					UpperCamelCase_       )		->	List[str]:







 '''simple docstring'''
 _enforce_args(UpperCamelCase_							,					UpperCamelCase_       )
 if n == 0:
  return 0
 UpperCamelCase			  =      float("""-inf"""       )
 for i in range(1							,					n + 1       ):
  UpperCamelCase			  =      max(
      UpperCamelCase_							,					prices[i - 1] + naive_cut_rod_recursive(n - i							,					UpperCamelCase_       )       )

 return max_revue





def 			lowercase(	UpperCamelCase_							,					UpperCamelCase_       )		->	Optional[Any]:







 '''simple docstring'''
 _enforce_args(UpperCamelCase_							,					UpperCamelCase_       )
 UpperCamelCase			  =      [float("""-inf"""       ) for _ in range(n + 1       )]
 return _top_down_cut_rod_recursive(UpperCamelCase_							,					UpperCamelCase_							,					UpperCamelCase_       )





def 			lowercase(	UpperCamelCase_							,					UpperCamelCase_							,					UpperCamelCase_       )		->	List[Any]:







 '''simple docstring'''
 if max_rev[n] >= 0:
  return max_rev[n]
 elif n == 0:
  return 0
 else:
  UpperCamelCase			  =      float("""-inf"""       )
  for i in range(1							,					n + 1       ):
   UpperCamelCase			  =      max(
       UpperCamelCase_							,					prices[i - 1] + _top_down_cut_rod_recursive(n - i							,					UpperCamelCase_							,					UpperCamelCase_       )							,					)

  UpperCamelCase			  =      max_revenue

 return max_rev[n]





def 			lowercase(	UpperCamelCase_							,					UpperCamelCase_       )		->	Union[str, Any]:







 '''simple docstring'''
 _enforce_args(UpperCamelCase_							,					UpperCamelCase_       )

 # length(max_rev) = n + 1, to accommodate for the revenue obtainable from a rod of
 # length 0.
 UpperCamelCase			  =      [float("""-inf"""       ) for _ in range(n + 1       )]
 UpperCamelCase			  =      0

 for i in range(1							,					n + 1       ):
  UpperCamelCase			  =      max_rev[i]
  for j in range(1							,					i + 1       ):
   UpperCamelCase			  =      max(UpperCamelCase_							,					prices[j - 1] + max_rev[i - j]       )

  UpperCamelCase			  =      max_revenue_i

 return max_rev[n]





def 			lowercase(	UpperCamelCase_							,					UpperCamelCase_       )		->	Union[str, Any]:







 '''simple docstring'''
 if n < 0:
  UpperCamelCase			  =      f"""n must be greater than or equal to 0. Got n = {n}"""
  raise ValueError(UpperCamelCase_       )

 if n > len(UpperCamelCase_       ):
  UpperCamelCase			  =      (
      """Each integral piece of rod must have a corresponding price. """
      f"""Got n = {n} but length of prices = {len(UpperCamelCase_       )}"""
  )
  raise ValueError(UpperCamelCase_       )





def 			lowercase(	)		->	str:







 '''simple docstring'''
 UpperCamelCase			  =      [6, 10, 12, 15, 20, 23]
 UpperCamelCase			  =      len(UpperCamelCase_       )

 # the best revenue comes from cutting the rod into 6 pieces, each
 # of length 1 resulting in a revenue of 6 * 6 = 36.
 UpperCamelCase			  =      36

 UpperCamelCase			  =      top_down_cut_rod(UpperCamelCase_							,					UpperCamelCase_       )
 UpperCamelCase			  =      bottom_up_cut_rod(UpperCamelCase_							,					UpperCamelCase_       )
 UpperCamelCase			  =      naive_cut_rod_recursive(UpperCamelCase_							,					UpperCamelCase_       )

 assert expected_max_revenue == max_rev_top_down
 assert max_rev_top_down == max_rev_bottom_up
 assert max_rev_bottom_up == max_rev_naive


if __name__ == "__main__":
     main()
