


'''simple docstring'''
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

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


enable_full_determinism()






@skip_mps
class 					__lowerCAmelCase   (   lowercase				,			unittest.TestCase						):

						"""simple docstring"""






						_UpperCAmelCase		:       int   						=TextToVideoSDPipeline
						_UpperCAmelCase		:       List[Any]   						=TEXT_TO_IMAGE_PARAMS
						_UpperCAmelCase		:       Union[str, Any]   						=TEXT_TO_IMAGE_BATCH_PARAMS
						# No `output_type`.
						_UpperCAmelCase		:       Tuple   						=frozenset(
						    [
						        "num_inference_steps",
						        "generator",
						        "latents",
						        "return_dict",
						        "callback",
						        "callback_steps",
						    ]						)






						def 				_UpperCAmelCase       (  self							:      Tuple	):
													torch.manual_seed(0	)
													A_			    =		UNetaDConditionModel(
													    block_out_channels=(32, 64, 64, 64) ,  layers_per_block=2 ,  sample_size=32 ,  in_channels=4 ,  out_channels=4 ,  down_block_types=("CrossAttnDownBlock3D", "CrossAttnDownBlock3D", "CrossAttnDownBlock3D", "DownBlock3D") ,  up_block_types=("UpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D") ,  cross_attention_dim=32 ,  attention_head_dim=4 ,  )
													A_			    =		DDIMScheduler(
													    beta_start=0.0_0_0_8_5 ,  beta_end=0.0_1_2 ,  beta_schedule="scaled_linear" ,  clip_sample=lowerCAmelCase ,  set_alpha_to_one=lowerCAmelCase ,  )
													torch.manual_seed(0	)
													A_			    =		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 ,  sample_size=1_28 ,  )
													torch.manual_seed(0	)
													A_			    =		CLIPTextConfig(
													    bos_token_id=0 ,  eos_token_id=2 ,  hidden_size=32 ,  intermediate_size=37 ,  layer_norm_eps=1e-05 ,  num_attention_heads=4 ,  num_hidden_layers=5 ,  pad_token_id=1 ,  vocab_size=10_00 ,  hidden_act="gelu" ,  projection_dim=5_12 ,  )
													A_			    =		CLIPTextModel(lowerCAmelCase	)
													A_			    =		CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

													A_			    =		{
													    "unet": unet,
													    "scheduler": scheduler,
													    "vae": vae,
													    "text_encoder": text_encoder,
													    "tokenizer": tokenizer,
													}
													return components






						def 				_UpperCAmelCase       (  self							:      Optional[int] ,  lowerCAmelCase							:      Any ,  lowerCAmelCase							:      List[str]=0	):
													if str(lowerCAmelCase	).startswith("mps"	):
																				A_			    =		torch.manual_seed(lowerCAmelCase	)
													else:
																				A_			    =		torch.Generator(device=lowerCAmelCase	).manual_seed(lowerCAmelCase	)
													A_			    =		{
													    "prompt": "A painting of a squirrel eating a burger",
													    "generator": generator,
													    "num_inference_steps": 2,
													    "guidance_scale": 6.0,
													    "output_type": "pt",
													}
													return inputs






						def 				_UpperCAmelCase       (  self							:      Optional[Any]	):
													A_			    =		"cpu"  # ensure determinism for the device-dependent torch.Generator
													A_			    =		self.get_dummy_components()
													A_			    =		TextToVideoSDPipeline(**lowerCAmelCase	)
													A_			    =		sd_pipe.to(lowerCAmelCase	)
													sd_pipe.set_progress_bar_config(disable=lowerCAmelCase	)

													A_			    =		self.get_dummy_inputs(lowerCAmelCase	)
													A_			    =		"np"
													A_			    =		sd_pipe(**lowerCAmelCase	).frames
													A_			    =		frames[0][-3:, -3:, -1]

													assert frames[0].shape == (64, 64, 3)
													A_			    =		np.array([1_5_8.0, 1_6_0.0, 1_5_3.0, 1_2_5.0, 1_0_0.0, 1_2_1.0, 1_1_1.0, 9_3.0, 1_1_3.0]	)

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






						def 				_UpperCAmelCase       (  self							:      str	):
													self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowerCAmelCase ,  expected_max_diff=3e-3	)






						@unittest.skipIf(
						    torch_device != "cuda" or not is_xformers_available() ,  reason="XFormers attention is only available with CUDA and `xformers` installed" ,  )
						def 				_UpperCAmelCase       (  self							:      Any	):
													self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCAmelCase ,  expected_max_diff=1e-2	)






						@unittest.skip(reason="Batching needs to be properly figured out first for this pipeline."	)
						def 				_UpperCAmelCase       (  self							:      Optional[int]	):
													pass






						@unittest.skip(reason="Batching needs to be properly figured out first for this pipeline."	)
						def 				_UpperCAmelCase       (  self							:      Tuple	):
													pass






						@unittest.skip(reason="`num_images_per_prompt` argument is not supported for this pipeline."	)
						def 				_UpperCAmelCase       (  self							:      Union[str, Any]	):
													pass






						def 				_UpperCAmelCase       (  self							:      str	):
													return super().test_progress_bar()






@slow
@skip_mps
class 					__lowerCAmelCase   (   unittest.TestCase						):

						"""simple docstring"""






						def 				_UpperCAmelCase       (  self							:      List[str]	):
													A_			    =		load_numpy(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy"	)

													A_			    =		TextToVideoSDPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b"	)
													A_			    =		DPMSolverMultistepScheduler.from_config(pipe.scheduler.config	)
													A_			    =		pipe.to("cuda"	)

													A_			    =		"Spiderman is surfing"
													A_			    =		torch.Generator(device="cpu"	).manual_seed(0	)

													A_			    =		pipe(lowerCAmelCase ,  generator=lowerCAmelCase ,  num_inference_steps=25 ,  output_type="pt"	).frames
													A_			    =		video_frames.cpu().numpy()

													assert np.abs(expected_video - video	).mean() < 5e-2






						def 				_UpperCAmelCase       (  self							:      Optional[Any]	):
													A_			    =		load_numpy(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy"	)

													A_			    =		TextToVideoSDPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b"	)
													A_			    =		pipe.to("cuda"	)

													A_			    =		"Spiderman is surfing"
													A_			    =		torch.Generator(device="cpu"	).manual_seed(0	)

													A_			    =		pipe(lowerCAmelCase ,  generator=lowerCAmelCase ,  num_inference_steps=2 ,  output_type="pt"	).frames
													A_			    =		video_frames.cpu().numpy()

													assert np.abs(expected_video - video	).mean() < 5e-2









'''simple docstring'''
from __future__ import annotations

from typing import Any







def       a_				(	UpperCamelCase_ ):
							create_state_space_tree(UpperCamelCase_						,  []						,  0 )







def       a_				(	UpperCamelCase_						,  UpperCamelCase_						,  UpperCamelCase_ ):

							if index == len(UpperCamelCase_ ):
														print(UpperCamelCase_ )
														return

							create_state_space_tree(UpperCamelCase_						,  UpperCamelCase_						,  index + 1 )
							current_subsequence.append(sequence[index] )
							create_state_space_tree(UpperCamelCase_						,  UpperCamelCase_						,  index + 1 )
							current_subsequence.pop()


if __name__ == "__main__":
							__SCREAMING_SNAKE_CASE					:				list[Any]									=		[3, 1, 2, 4]
							generate_all_subsequences(seq)

							seq.clear()
							seq.extend(['''A''', '''B''', '''C'''])
							generate_all_subsequences(seq)





