





import gc
import random
import tempfile
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


class        __SCREAMING_SNAKE_CASE      (			unittest.TestCase ):







       def 						__lowerCamelCase   (				self					:     Any      )       ->int:
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()







       @property
       def 						__lowerCamelCase   (				self					:     Optional[Any]      )       ->Dict:
          lowerCamelCase__       :						Any        =							1
          lowerCamelCase__       :						Tuple        =							3
          lowerCamelCase__       :						str        =							(3_2, 3_2)

          lowerCamelCase__       :						List[Any]        =							floats_tensor((batch_size, num_channels) + sizes		, rng=random.Random(0      )      ).to(A      )
          return image







       @property
       def 						__lowerCamelCase   (				self					:     Any      )       ->List[Any]:
          torch.manual_seed(0      )
          lowerCamelCase__       :						Tuple        =							UNetaDConditionModel(
              block_out_channels=(3_2, 6_4)		, layers_per_block=2		, sample_size=3_2		, in_channels=4		, out_channels=4		, down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')		, up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')		, cross_attention_dim=3_2		, )
          return model







       @property
       def 						__lowerCamelCase   (				self					:     List[str]      )       ->str:
          torch.manual_seed(0      )
          lowerCamelCase__       :						List[str]        =							AutoencoderKL(
              block_out_channels=[3_2, 6_4]		, in_channels=3		, out_channels=3		, down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']		, up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']		, latent_channels=4		, )
          return model







       @property
       def 						__lowerCamelCase   (				self					:     Union[str, Any]      )       ->Optional[int]:
          torch.manual_seed(0      )
          lowerCamelCase__       :						Dict        =							CLIPTextConfig(
              bos_token_id=0		, eos_token_id=2		, hidden_size=3_2		, 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 CLIPTextModel(A      )







       @property
       def 						__lowerCamelCase   (				self					:     Optional[Any]      )       ->Optional[int]:
          def extract(*A					:     Union[str, Any]		, **A					:     Optional[Any]      ):


             class        __SCREAMING_SNAKE_CASE      :







                    def __init__(				self					:     int      )       ->int:
                       lowerCamelCase__       :						List[Any]        =							torch.ones([0]      )







                    def 						__lowerCamelCase   (				self					:     str		, A					:     Tuple      )       ->Dict:
                       self.pixel_values.to(A      )
                       return self


             return Out()

          return extract







       def 						__lowerCamelCase   (				self					:     Union[str, Any]      )       ->Any:
          lowerCamelCase__       :						Tuple        =							'''cpu'''  # ensure determinism for the device-dependent torch.Generator
          lowerCamelCase__       :						List[str]        =							self.dummy_cond_unet
          lowerCamelCase__       :						Optional[Any]        =							DDIMScheduler(
              beta_start=0.0_00_85		, beta_end=0.0_12		, beta_schedule='''scaled_linear'''		, clip_sample=A		, set_alpha_to_one=A		, )

          lowerCamelCase__       :						str        =							self.dummy_vae
          lowerCamelCase__       :						List[Any]        =							self.dummy_text_encoder
          lowerCamelCase__       :						Tuple        =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

          # make sure here that pndm scheduler skips prk
          lowerCamelCase__       :						int        =							StableDiffusionPipeline(
              unet=A		, scheduler=A		, vae=A		, text_encoder=A		, tokenizer=A		, safety_checker=A		, feature_extractor=self.dummy_extractor		, )
          lowerCamelCase__       :						List[Any]        =							sd_pipe.to(A      )
          sd_pipe.set_progress_bar_config(disable=A      )

          lowerCamelCase__       :						str        =							'''A painting of a squirrel eating a burger'''

          lowerCamelCase__       :						Tuple        =							torch.Generator(device=A      ).manual_seed(0      )
          lowerCamelCase__       :						Optional[int]        =							sd_pipe([prompt]		, generator=A		, guidance_scale=6.0		, num_inference_steps=2		, output_type='''np'''      )
          lowerCamelCase__       :						Optional[int]        =							output.images

          lowerCamelCase__       :						str        =							torch.Generator(device=A      ).manual_seed(0      )
          lowerCamelCase__       :						Tuple        =							sd_pipe(
              [prompt]		, generator=A		, guidance_scale=6.0		, num_inference_steps=2		, output_type='''np'''		, return_dict=A		, )[0]

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

          assert image.shape == (1, 6_4, 6_4, 3)
          lowerCamelCase__       :						Tuple        =							np.array([0.57_56, 0.61_18, 0.50_05, 0.50_41, 0.54_71, 0.47_26, 0.49_76, 0.48_65, 0.48_64]      )

          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 						__lowerCamelCase   (				self					:     Dict      )       ->Optional[int]:
          lowerCamelCase__       :						int        =							'''cpu'''  # ensure determinism for the device-dependent torch.Generator
          lowerCamelCase__       :						List[str]        =							self.dummy_cond_unet
          lowerCamelCase__       :						List[Any]        =							PNDMScheduler(skip_prk_steps=A      )
          lowerCamelCase__       :						Optional[Any]        =							self.dummy_vae
          lowerCamelCase__       :						str        =							self.dummy_text_encoder
          lowerCamelCase__       :						List[str]        =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

          # make sure here that pndm scheduler skips prk
          lowerCamelCase__       :						Tuple        =							StableDiffusionPipeline(
              unet=A		, scheduler=A		, vae=A		, text_encoder=A		, tokenizer=A		, safety_checker=A		, feature_extractor=self.dummy_extractor		, )
          lowerCamelCase__       :						List[str]        =							sd_pipe.to(A      )
          sd_pipe.set_progress_bar_config(disable=A      )

          lowerCamelCase__       :						Tuple        =							'''A painting of a squirrel eating a burger'''
          lowerCamelCase__       :						Any        =							torch.Generator(device=A      ).manual_seed(0      )
          lowerCamelCase__       :						List[Any]        =							sd_pipe([prompt]		, generator=A		, guidance_scale=6.0		, num_inference_steps=2		, output_type='''np'''      )

          lowerCamelCase__       :						Any        =							output.images

          lowerCamelCase__       :						List[Any]        =							torch.Generator(device=A      ).manual_seed(0      )
          lowerCamelCase__       :						List[Any]        =							sd_pipe(
              [prompt]		, generator=A		, guidance_scale=6.0		, num_inference_steps=2		, output_type='''np'''		, return_dict=A		, )[0]

          lowerCamelCase__       :						Optional[Any]        =							image[0, -3:, -3:, -1]
          lowerCamelCase__       :						Tuple        =							image_from_tuple[0, -3:, -3:, -1]

          assert image.shape == (1, 6_4, 6_4, 3)
          lowerCamelCase__       :						int        =							np.array([0.51_25, 0.57_16, 0.48_28, 0.50_60, 0.56_50, 0.47_68, 0.51_85, 0.48_95, 0.49_93]      )

          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 						__lowerCamelCase   (				self					:     str      )       ->int:
          lowerCamelCase__       :						List[str]        =							StableDiffusionPipeline.from_pretrained(
              '''hf-internal-testing/tiny-stable-diffusion-lms-pipe'''		, safety_checker=A      )
          assert isinstance(A		, A      )
          assert isinstance(pipe.scheduler		, A      )
          assert pipe.safety_checker is None

          lowerCamelCase__       :						Union[str, Any]        =							pipe('''example prompt'''		, num_inference_steps=2      ).images[0]
          assert image is not None

          # check that there's no error when saving a pipeline with one of the models being None
          with tempfile.TemporaryDirectory() as tmpdirname:
             pipe.save_pretrained(A      )
             lowerCamelCase__       :						Optional[Any]        =							StableDiffusionPipeline.from_pretrained(A      )

          # sanity check that the pipeline still works
          assert pipe.safety_checker is None
          lowerCamelCase__       :						Union[str, Any]        =							pipe('''example prompt'''		, num_inference_steps=2      ).images[0]
          assert image is not None







       @unittest.skipIf(torch_device != '''cuda'''		, '''This test requires a GPU'''      )
       def 						__lowerCamelCase   (				self					:     int      )       ->str:
          lowerCamelCase__       :						Any        =							self.dummy_cond_unet
          lowerCamelCase__       :						Dict        =							PNDMScheduler(skip_prk_steps=A      )
          lowerCamelCase__       :						Union[str, Any]        =							self.dummy_vae
          lowerCamelCase__       :						int        =							self.dummy_text_encoder
          lowerCamelCase__       :						List[Any]        =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

          # put models in fp16
          lowerCamelCase__       :						int        =							unet.half()
          lowerCamelCase__       :						List[Any]        =							vae.half()
          lowerCamelCase__       :						Tuple        =							bert.half()

          # make sure here that pndm scheduler skips prk
          lowerCamelCase__       :						Tuple        =							StableDiffusionPipeline(
              unet=A		, scheduler=A		, vae=A		, text_encoder=A		, tokenizer=A		, safety_checker=A		, feature_extractor=self.dummy_extractor		, )
          lowerCamelCase__       :						Tuple        =							sd_pipe.to(A      )
          sd_pipe.set_progress_bar_config(disable=A      )

          lowerCamelCase__       :						Union[str, Any]        =							'''A painting of a squirrel eating a burger'''
          lowerCamelCase__       :						str        =							sd_pipe([prompt]		, num_inference_steps=2		, output_type='''np'''      ).images

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


@nightly
@require_torch_gpu
class        __SCREAMING_SNAKE_CASE      (			unittest.TestCase ):







       def 						__lowerCamelCase   (				self					:     List[str]      )       ->Dict:
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()







       def 						__lowerCamelCase   (				self					:     List[Any]      )       ->Optional[int]:
          lowerCamelCase__       :						int        =							StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''		, safety_checker=A      )
          lowerCamelCase__       :						Any        =							LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config      )
          lowerCamelCase__       :						Any        =							sd_pipe.to(A      )
          sd_pipe.set_progress_bar_config(disable=A      )

          lowerCamelCase__       :						int        =							(
              '''portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle'''
              ''' coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with'''
              ''' anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and'''
              ''' children from bahnhof zoo, detailed '''
          )
          lowerCamelCase__       :						List[str]        =							4_0_0_3_6_6_0_3_4_6
          lowerCamelCase__       :						List[str]        =							7

          # without safety guidance (sld_guidance_scale = 0)
          lowerCamelCase__       :						Dict        =							torch.manual_seed(A      )
          lowerCamelCase__       :						List[Any]        =							sd_pipe(
              [prompt]		, generator=A		, guidance_scale=A		, num_inference_steps=5_0		, output_type='''np'''		, width=5_1_2		, height=5_1_2		, sld_guidance_scale=0		, )

          lowerCamelCase__       :						List[Any]        =							output.images
          lowerCamelCase__       :						str        =							image[0, -3:, -3:, -1]
          lowerCamelCase__       :						Any        =							[0.22_78, 0.22_31, 0.22_49, 0.23_33, 0.23_03, 0.18_85, 0.22_73, 0.21_44, 0.21_76]

          assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

          # without safety guidance (strong configuration)
          lowerCamelCase__       :						str        =							torch.manual_seed(A      )
          lowerCamelCase__       :						int        =							sd_pipe(
              [prompt]		, generator=A		, guidance_scale=A		, num_inference_steps=5_0		, output_type='''np'''		, width=5_1_2		, height=5_1_2		, sld_guidance_scale=2_0_0_0		, sld_warmup_steps=7		, sld_threshold=0.0_25		, sld_momentum_scale=0.5		, sld_mom_beta=0.7		, )

          lowerCamelCase__       :						Any        =							output.images
          lowerCamelCase__       :						List[Any]        =							image[0, -3:, -3:, -1]
          lowerCamelCase__       :						int        =							[0.23_83, 0.22_76, 0.2_36, 0.21_92, 0.21_86, 0.20_53, 0.19_71, 0.19_01, 0.17_19]

          assert image.shape == (1, 5_1_2, 5_1_2, 3)

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







       def 						__lowerCamelCase   (				self					:     Optional[int]      )       ->Any:
          lowerCamelCase__       :						List[Any]        =							StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''		, safety_checker=A      )
          lowerCamelCase__       :						List[Any]        =							LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config      )
          lowerCamelCase__       :						Optional[Any]        =							sd_pipe.to(A      )
          sd_pipe.set_progress_bar_config(disable=A      )

          lowerCamelCase__       :						str        =							'''padme amidala taking a bath artwork, safe for work, no nudity'''
          lowerCamelCase__       :						int        =							2_7_3_4_9_7_1_7_5_5
          lowerCamelCase__       :						List[str]        =							7

          lowerCamelCase__       :						Dict        =							torch.manual_seed(A      )
          lowerCamelCase__       :						Optional[int]        =							sd_pipe(
              [prompt]		, generator=A		, guidance_scale=A		, num_inference_steps=5_0		, output_type='''np'''		, width=5_1_2		, height=5_1_2		, sld_guidance_scale=0		, )

          lowerCamelCase__       :						str        =							output.images
          lowerCamelCase__       :						int        =							image[0, -3:, -3:, -1]
          lowerCamelCase__       :						Tuple        =							[0.35_02, 0.36_22, 0.33_96, 0.36_42, 0.34_78, 0.33_18, 0.35, 0.33_48, 0.32_97]

          assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

          lowerCamelCase__       :						Any        =							torch.manual_seed(A      )
          lowerCamelCase__       :						List[Any]        =							sd_pipe(
              [prompt]		, generator=A		, guidance_scale=A		, num_inference_steps=5_0		, output_type='''np'''		, width=5_1_2		, height=5_1_2		, sld_guidance_scale=2_0_0_0		, sld_warmup_steps=7		, sld_threshold=0.0_25		, sld_momentum_scale=0.5		, sld_mom_beta=0.7		, )

          lowerCamelCase__       :						Union[str, Any]        =							output.images
          lowerCamelCase__       :						List[str]        =							image[0, -3:, -3:, -1]
          lowerCamelCase__       :						Optional[int]        =							[0.55_31, 0.52_06, 0.48_95, 0.51_56, 0.51_82, 0.47_51, 0.48_02, 0.48_03, 0.44_43]

          assert image.shape == (1, 5_1_2, 5_1_2, 3)

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







       def 						__lowerCamelCase   (				self					:     List[str]      )       ->int:
          lowerCamelCase__       :						Optional[Any]        =							StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''      )
          lowerCamelCase__       :						Union[str, Any]        =							sd_pipe.to(A      )
          sd_pipe.set_progress_bar_config(disable=A      )

          lowerCamelCase__       :						Any        =							(
              '''the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c.'''
              ''' leyendecker'''
          )
          lowerCamelCase__       :						Tuple        =							1_0_4_4_3_5_5_2_3_4
          lowerCamelCase__       :						Any        =							1_2

          lowerCamelCase__       :						int        =							torch.manual_seed(A      )
          lowerCamelCase__       :						Dict        =							sd_pipe(
              [prompt]		, generator=A		, guidance_scale=A		, num_inference_steps=5_0		, output_type='''np'''		, width=5_1_2		, height=5_1_2		, sld_guidance_scale=0		, )

          lowerCamelCase__       :						Optional[Any]        =							output.images
          lowerCamelCase__       :						int        =							image[0, -3:, -3:, -1]
          lowerCamelCase__       :						Any        =							np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]      )

          assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

          lowerCamelCase__       :						Union[str, Any]        =							torch.manual_seed(A      )
          lowerCamelCase__       :						List[Any]        =							sd_pipe(
              [prompt]		, generator=A		, guidance_scale=A		, num_inference_steps=5_0		, output_type='''np'''		, width=5_1_2		, height=5_1_2		, sld_guidance_scale=2_0_0_0		, sld_warmup_steps=7		, sld_threshold=0.0_25		, sld_momentum_scale=0.5		, sld_mom_beta=0.7		, )

          lowerCamelCase__       :						Any        =							output.images
          lowerCamelCase__       :						List[Any]        =							image[0, -3:, -3:, -1]
          lowerCamelCase__       :						str        =							np.array([0.58_18, 0.62_85, 0.68_35, 0.60_19, 0.6_25, 0.67_54, 0.60_96, 0.63_34, 0.65_61]      )
          assert image.shape == (1, 5_1_2, 5_1_2, 3)

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










from ...configuration_utils import PretrainedConfig
from ...utils import logging


_A :   Any  			=  logging.get_logger(__name__)

_A :   int  			=  {
    'facebook/timesformer': 'https://huggingface.co/facebook/timesformer/resolve/main/config.json',
}


class        __SCREAMING_SNAKE_CASE      (			lowerCAmelCase_ ):
       _UpperCAmelCase				:  Dict			   =   "timesformer"







       def __init__(				self					:     List[str]		, A					:     int=2_2_4		, A					:     Optional[Any]=1_6		, A					:     str=3		, A					:     str=8		, A					:     Any=7_6_8		, A					:     Dict=1_2		, A					:     Optional[Any]=1_2		, A					:     Any=3_0_7_2		, A					:     str="gelu"		, A					:     Optional[int]=0.0		, A					:     Union[str, Any]=0.0		, A					:     List[Any]=0.02		, A					:     int=1e-6		, A					:     Tuple=True		, A					:     Any="divided_space_time"		, A					:     Optional[Any]=0		, **A					:     Tuple		, )       ->str:
          super().__init__(**A      )

          lowerCamelCase__       :						Optional[Any]        =							image_size
          lowerCamelCase__       :						int        =							patch_size
          lowerCamelCase__       :						Any        =							num_channels
          lowerCamelCase__       :						Optional[int]        =							num_frames

          lowerCamelCase__       :						Optional[Any]        =							hidden_size
          lowerCamelCase__       :						Optional[int]        =							num_hidden_layers
          lowerCamelCase__       :						Optional[int]        =							num_attention_heads
          lowerCamelCase__       :						Dict        =							intermediate_size
          lowerCamelCase__       :						Optional[Any]        =							hidden_act
          lowerCamelCase__       :						Union[str, Any]        =							hidden_dropout_prob
          lowerCamelCase__       :						Dict        =							attention_probs_dropout_prob
          lowerCamelCase__       :						List[Any]        =							initializer_range
          lowerCamelCase__       :						str        =							layer_norm_eps
          lowerCamelCase__       :						Union[str, Any]        =							qkv_bias

          lowerCamelCase__       :						str        =							attention_type
          lowerCamelCase__       :						List[str]        =							drop_path_rate



