import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, XLMRobertaTokenizer

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

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


enable_full_determinism()







class __snake_case       (		lowerCamelCase_     ,	lowerCamelCase_     ,	lowerCamelCase_     ,	unittest.TestCase	):
   lowerCAmelCase_														=							AltDiffusionPipeline
   lowerCAmelCase_														=							TEXT_TO_IMAGE_PARAMS
   lowerCAmelCase_														=							TEXT_TO_IMAGE_BATCH_PARAMS
   lowerCAmelCase_														=							TEXT_TO_IMAGE_IMAGE_PARAMS
   lowerCAmelCase_														=							TEXT_TO_IMAGE_IMAGE_PARAMS




   def 			__a		(					self    :       str   ):



     """simple docstring"""






     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__    							=   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""") ,			cross_attention_dim=32 ,			)
     SCREAMING_SNAKE_CASE__    							=   DDIMScheduler(
         beta_start=0.0_00_85 ,			beta_end=0.0_12 ,			beta_schedule="""scaled_linear""" ,			clip_sample=_lowercase ,			set_alpha_to_one=_lowercase ,			)
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__    							=   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 ,			)

     # TODO: address the non-deterministic text encoder (fails for save-load tests)
     # torch.manual_seed(0)
     # text_encoder_config = RobertaSeriesConfig(
     #     hidden_size=32,
     #     project_dim=32,
     #     intermediate_size=37,
     #     layer_norm_eps=1e-05,
     #     num_attention_heads=4,
     #     num_hidden_layers=5,
     #     vocab_size=5002,
     # )
     # text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__    							=   CLIPTextConfig(
         bos_token_id=0 ,			eos_token_id=2 ,			hidden_size=32 ,			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=50_02 ,			)
     SCREAMING_SNAKE_CASE__    							=   CLIPTextModel(_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   XLMRobertaTokenizer.from_pretrained("""hf-internal-testing/tiny-xlm-roberta"""   )
     SCREAMING_SNAKE_CASE__    							=   77

     SCREAMING_SNAKE_CASE__    							=   {
         """unet""": unet,
         """scheduler""": scheduler,
         """vae""": vae,
         """text_encoder""": text_encoder,
         """tokenizer""": tokenizer,
         """safety_checker""": None,
         """feature_extractor""": None,
     }
     return components




   def 			__a		(					self    :       int ,			_lowercase    :       Any ,			_lowercase    :       Any=0   ):



     """simple docstring"""






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




   def 			__a		(					self    :       Optional[int]   ):



     """simple docstring"""






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




   def 			__a		(					self    :       int   ):



     """simple docstring"""






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




   def 			__a		(					self    :       int   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   """cpu"""  # ensure determinism for the device-dependent torch.Generator

     SCREAMING_SNAKE_CASE__    							=   self.get_dummy_components()
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__    							=   RobertaSeriesConfig(
         hidden_size=32 ,			project_dim=32 ,			intermediate_size=37 ,			layer_norm_eps=1E-05 ,			num_attention_heads=4 ,			num_hidden_layers=5 ,			vocab_size=50_02 ,			)
     # TODO: remove after fixing the non-deterministic text encoder
     SCREAMING_SNAKE_CASE__    							=   RobertaSeriesModelWithTransformation(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   text_encoder

     SCREAMING_SNAKE_CASE__    							=   AltDiffusionPipeline(**_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   alt_pipe.to(_lowercase   )
     alt_pipe.set_progress_bar_config(disable=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   self.get_dummy_inputs(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   """A photo of an astronaut"""
     SCREAMING_SNAKE_CASE__    							=   alt_pipe(**_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   output.images
     SCREAMING_SNAKE_CASE__    							=   image[0, -3:, -3:, -1]

     assert image.shape == (1, 64, 64, 3)
     SCREAMING_SNAKE_CASE__    							=   np.array(
         [0.5_74_81_62, 0.60_44_71_45, 0.48_82_12_17, 0.50_10_06_36, 0.5_43_11_85, 0.45_76_36_83, 0.49_65_76_96, 0.48_13_27_33, 0.47_57_30_93]   )

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




   def 			__a		(					self    :       Tuple   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   """cpu"""  # ensure determinism for the device-dependent torch.Generator

     SCREAMING_SNAKE_CASE__    							=   self.get_dummy_components()
     SCREAMING_SNAKE_CASE__    							=   PNDMScheduler(skip_prk_steps=_lowercase   )
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__    							=   RobertaSeriesConfig(
         hidden_size=32 ,			project_dim=32 ,			intermediate_size=37 ,			layer_norm_eps=1E-05 ,			num_attention_heads=4 ,			num_hidden_layers=5 ,			vocab_size=50_02 ,			)
     # TODO: remove after fixing the non-deterministic text encoder
     SCREAMING_SNAKE_CASE__    							=   RobertaSeriesModelWithTransformation(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   text_encoder
     SCREAMING_SNAKE_CASE__    							=   AltDiffusionPipeline(**_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   alt_pipe.to(_lowercase   )
     alt_pipe.set_progress_bar_config(disable=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   self.get_dummy_inputs(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   alt_pipe(**_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   output.images
     SCREAMING_SNAKE_CASE__    							=   image[0, -3:, -3:, -1]

     assert image.shape == (1, 64, 64, 3)
     SCREAMING_SNAKE_CASE__    							=   np.array(
         [0.51_60_50_93, 0.5_70_72_41, 0.47_36_55_07, 0.50_57_88_86, 0.5_63_38_77, 0.4_64_25_03, 0.5_18_20_81, 0.48_76_34_84, 0.49_08_42_37]   )

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







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




   def 			__a		(					self    :       List[Any]   ):



     """simple docstring"""






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




   def 			__a		(					self    :       Any   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   AltDiffusionPipeline.from_pretrained("""BAAI/AltDiffusion""" ,			safety_checker=_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   alt_pipe.to(_lowercase   )
     alt_pipe.set_progress_bar_config(disable=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   """A painting of a squirrel eating a burger"""
     SCREAMING_SNAKE_CASE__    							=   torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__    							=   alt_pipe([prompt] ,			generator=_lowercase ,			guidance_scale=6.0 ,			num_inference_steps=20 ,			output_type="""np"""   )

     SCREAMING_SNAKE_CASE__    							=   output.images

     SCREAMING_SNAKE_CASE__    							=   image[0, -3:, -3:, -1]

     assert image.shape == (1, 5_12, 5_12, 3)
     SCREAMING_SNAKE_CASE__    							=   np.array([0.10_10, 0.08_00, 0.07_94, 0.08_85, 0.08_43, 0.07_62, 0.07_69, 0.07_29, 0.05_86]   )

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




   def 			__a		(					self    :       Any   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   DDIMScheduler.from_pretrained("""BAAI/AltDiffusion""" ,			subfolder="""scheduler"""   )

     SCREAMING_SNAKE_CASE__    							=   AltDiffusionPipeline.from_pretrained("""BAAI/AltDiffusion""" ,			scheduler=_lowercase ,			safety_checker=_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   alt_pipe.to(_lowercase   )
     alt_pipe.set_progress_bar_config(disable=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   """A painting of a squirrel eating a burger"""
     SCREAMING_SNAKE_CASE__    							=   torch.manual_seed(0   )

     SCREAMING_SNAKE_CASE__    							=   alt_pipe([prompt] ,			generator=_lowercase ,			num_inference_steps=2 ,			output_type="""numpy"""   )
     SCREAMING_SNAKE_CASE__    							=   output.images

     SCREAMING_SNAKE_CASE__    							=   image[0, -3:, -3:, -1]

     assert image.shape == (1, 5_12, 5_12, 3)
     SCREAMING_SNAKE_CASE__    							=   np.array([0.40_19, 0.40_52, 0.38_10, 0.41_19, 0.39_16, 0.39_82, 0.46_51, 0.41_95, 0.53_23]   )

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

def 			__SCREAMING_SNAKE_CASE						(      __UpperCamelCase					: list				,  __UpperCamelCase					: list				,  __UpperCamelCase					: int				,  __UpperCamelCase					: int				,  __UpperCamelCase					: int			)							->      int:







  """simple docstring"""





  if index == number_of_items:
    return 0
  SCREAMING_SNAKE_CASE__    							=   0
  SCREAMING_SNAKE_CASE__    							=   0
  SCREAMING_SNAKE_CASE__    							=   knapsack(__UpperCamelCase				,  __UpperCamelCase				,  __UpperCamelCase				,  __UpperCamelCase				,  index + 1			)
  if weights[index] <= max_weight:
    SCREAMING_SNAKE_CASE__    							=   values[index] + knapsack(
        __UpperCamelCase				,  __UpperCamelCase				,  __UpperCamelCase				,  max_weight - weights[index]				,  index + 1			)
  return max(__UpperCamelCase				,  __UpperCamelCase			)


if __name__ == "__main__":
   import doctest

   doctest.testmod()
