

from dataclasses import dataclass
from typing import Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .embeddings import GaussianFourierProjection, TimestepEmbedding, Timesteps
from .modeling_utils import ModelMixin
from .unet_ad_blocks import get_down_block, get_mid_block, get_out_block, get_up_block



@dataclass
class 					_a		(__magic_name__       ):


					'''simple docstring'''






					UpperCAmelCase__:     torch.FloatTensor



class 					_a		(__magic_name__	,     __magic_name__       ):


					'''simple docstring'''






					@register_to_config
					def __init__(				self					, A__ = 6_5536					, A__ = None					, A__ = 2					, A__ = 2					, A__ = 0					, A__ = "fourier"					, A__ = True					, A__ = False					, A__ = 0.0					, A__ = ("DownBlock1DNoSkip", "DownBlock1D", "AttnDownBlock1D")					, A__ = ("AttnUpBlock1D", "UpBlock1D", "UpBlock1DNoSkip")					, A__ = "UNetMidBlock1D"					, A__ = None					, A__ = (32, 32, 64)					, A__ = None					, A__ = 8					, A__ = 1					, A__ = False					, ):
						super().__init__()
						A__							:					str       =	sample_size

						# time
						if time_embedding_type == "fourier":
							A__							:					Optional[Any]       =	GaussianFourierProjection(
							    embedding_size=8					, set_W_to_weight=A__					, log=A__					, flip_sin_to_cos=A__    )
							A__							:					Optional[int]       =	2 * block_out_channels[0]
						elif time_embedding_type == "positional":
							A__							:					Optional[Any]       =	Timesteps(
							    block_out_channels[0]					, flip_sin_to_cos=A__					, downscale_freq_shift=A__    )
							A__							:					int       =	block_out_channels[0]

						if use_timestep_embedding:
							A__							:					Any       =	block_out_channels[0] * 4
							A__							:					List[Any]       =	TimestepEmbedding(
							    in_channels=A__					, time_embed_dim=A__					, act_fn=A__					, out_dim=block_out_channels[0]					, )

						A__							:					int       =	nn.ModuleList([]    )
						A__							:					Tuple       =	None
						A__							:					List[str]       =	nn.ModuleList([]    )
						A__							:					int       =	None

						# down
						A__							:					List[str]       =	in_channels
						for i, down_block_type in enumerate(A__    ):
							A__							:					Optional[Any]       =	output_channel
							A__							:					Optional[Any]       =	block_out_channels[i]

							if i == 0:
								input_channel += extra_in_channels

							A__							:					str       =	i == len(A__    ) - 1

							A__							:					Any       =	get_down_block(
							    A__					, num_layers=A__					, in_channels=A__					, out_channels=A__					, temb_channels=block_out_channels[0]					, add_downsample=not is_final_block or downsample_each_block					, )
							self.down_blocks.append(A__    )

						# mid
						A__							:					List[str]       =	get_mid_block(
						    A__					, in_channels=block_out_channels[-1]					, mid_channels=block_out_channels[-1]					, out_channels=block_out_channels[-1]					, embed_dim=block_out_channels[0]					, num_layers=A__					, add_downsample=A__					, )

						# up
						A__							:					Union[str, Any]       =	list(reversed(A__    )    )
						A__							:					int       =	reversed_block_out_channels[0]
						if out_block_type is None:
							A__							:					str       =	out_channels
						else:
							A__							:					Any       =	block_out_channels[0]

						for i, up_block_type in enumerate(A__    ):
							A__							:					List[str]       =	output_channel
							A__							:					str       =	(
							    reversed_block_out_channels[i + 1] if i < len(A__    ) - 1 else final_upsample_channels
							)

							A__							:					int       =	i == len(A__    ) - 1

							A__							:					str       =	get_up_block(
							    A__					, num_layers=A__					, in_channels=A__					, out_channels=A__					, temb_channels=block_out_channels[0]					, add_upsample=not is_final_block					, )
							self.up_blocks.append(A__    )
							A__							:					Dict       =	output_channel

						# out
						A__							:					Union[str, Any]       =	norm_num_groups if norm_num_groups is not None else min(block_out_channels[0] // 4					, 32    )
						A__							:					List[Any]       =	get_out_block(
						    out_block_type=A__					, num_groups_out=A__					, embed_dim=block_out_channels[0]					, out_channels=A__					, act_fn=A__					, fc_dim=block_out_channels[-1] // 4					, )






					def 						__A    (				self					, A__					, A__					, A__ = True					, ):
						A__							:					Any       =	timestep
						if not torch.is_tensor(A__    ):
							A__							:					Tuple       =	torch.tensor([timesteps]					, dtype=torch.long					, device=sample.device    )
						elif torch.is_tensor(A__    ) and len(timesteps.shape    ) == 0:
							A__							:					Optional[Any]       =	timesteps[None].to(sample.device    )

						A__							:					List[str]       =	self.time_proj(A__    )
						if self.config.use_timestep_embedding:
							A__							:					Tuple       =	self.time_mlp(A__    )
						else:
							A__							:					Optional[int]       =	timestep_embed[..., None]
							A__							:					Tuple       =	timestep_embed.repeat([1, 1, sample.shape[2]]    ).to(sample.dtype    )
							A__							:					Union[str, Any]       =	timestep_embed.broadcast_to((sample.shape[:1] + timestep_embed.shape[1:])    )

						# 2. down
						A__							:					List[str]       =	()
						for downsample_block in self.down_blocks:
							A__     ,     A__							:					str       =	downsample_block(hidden_states=A__					, temb=A__    )
							down_block_res_samples += res_samples

						# 3. mid
						if self.mid_block:
							A__							:					Any       =	self.mid_block(A__					, A__    )

						# 4. up
						for i, upsample_block in enumerate(self.up_blocks    ):
							A__							:					int       =	down_block_res_samples[-1:]
							A__							:					str       =	down_block_res_samples[:-1]
							A__							:					List[Any]       =	upsample_block(A__					, res_hidden_states_tuple=A__					, temb=A__    )

						# 5. post-process
						if self.out_block:
							A__							:					str       =	self.out_block(A__					, A__    )

						if not return_dict:
							return (sample,)

						return UNetaDOutput(sample=A__    )






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 					_a		(__magic_name__	,     unittest.TestCase       ):


					'''simple docstring'''






					UpperCAmelCase__:     Any													= TextToVideoSDPipeline
					UpperCAmelCase__:     Any													= TEXT_TO_IMAGE_PARAMS
					UpperCAmelCase__:     Optional[Any]													= TEXT_TO_IMAGE_BATCH_PARAMS
					# No `output_type`.
					UpperCAmelCase__:     Optional[int]													= frozenset(
					    [
					        '''num_inference_steps''',
					        '''generator''',
					        '''latents''',
					        '''return_dict''',
					        '''callback''',
					        '''callback_steps''',
					    ]       )






					def 						__A    (				self    ):
						torch.manual_seed(0    )
						A__							:					Optional[int]       =	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__							:					Optional[int]       =	DDIMScheduler(
						    beta_start=0.0_0_0_8_5					, beta_end=0.0_1_2					, beta_schedule="""scaled_linear"""					, clip_sample=A__					, set_alpha_to_one=A__					, )
						torch.manual_seed(0    )
						A__							:					Union[str, Any]       =	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=128					, )
						torch.manual_seed(0    )
						A__							:					Union[str, Any]       =	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=1000					, hidden_act="""gelu"""					, projection_dim=512					, )
						A__							:					Union[str, Any]       =	CLIPTextModel(A__    )
						A__							:					Tuple       =	CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""    )

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






					def 						__A    (				self					, A__					, A__=0    ):
						if str(A__    ).startswith("""mps"""    ):
							A__							:					Tuple       =	torch.manual_seed(A__    )
						else:
							A__							:					List[str]       =	torch.Generator(device=A__    ).manual_seed(A__    )
						A__							:					List[str]       =	{
						    """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 						__A    (				self    ):
						A__							:					List[str]       =	"""cpu"""  # ensure determinism for the device-dependent torch.Generator
						A__							:					Union[str, Any]       =	self.get_dummy_components()
						A__							:					Union[str, Any]       =	TextToVideoSDPipeline(**A__    )
						A__							:					int       =	sd_pipe.to(A__    )
						sd_pipe.set_progress_bar_config(disable=A__    )

						A__							:					int       =	self.get_dummy_inputs(A__    )
						A__							:					int       =	"""np"""
						A__							:					Any       =	sd_pipe(**A__    ).frames
						A__							:					Dict       =	frames[0][-3:, -3:, -1]

						assert frames[0].shape == (64, 64, 3)
						A__							:					Optional[Any]       =	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 						__A    (				self    ):
						self._test_attention_slicing_forward_pass(test_mean_pixel_difference=A__					, 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 						__A    (				self    ):
						self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=A__					, expected_max_diff=1e-2    )






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






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






					@unittest.skip(reason="""`num_images_per_prompt` argument is not supported for this pipeline."""    )
					def 						__A    (				self    ):
						pass






					def 						__A    (				self    ):
						return super().test_progress_bar()



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


					'''simple docstring'''






					def 						__A    (				self    ):
						A__							:					Union[str, Any]       =	load_numpy(
						    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy"""    )

						A__							:					Tuple       =	TextToVideoSDPipeline.from_pretrained("""damo-vilab/text-to-video-ms-1.7b"""    )
						A__							:					Any       =	DPMSolverMultistepScheduler.from_config(pipe.scheduler.config    )
						A__							:					int       =	pipe.to("""cuda"""    )

						A__							:					Optional[Any]       =	"""Spiderman is surfing"""
						A__							:					List[str]       =	torch.Generator(device="""cpu"""    ).manual_seed(0    )

						A__							:					Optional[Any]       =	pipe(A__					, generator=A__					, num_inference_steps=25					, output_type="""pt"""    ).frames
						A__							:					Dict       =	video_frames.cpu().numpy()

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






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

						A__							:					Optional[int]       =	TextToVideoSDPipeline.from_pretrained("""damo-vilab/text-to-video-ms-1.7b"""    )
						A__							:					List[str]       =	pipe.to("""cuda"""    )

						A__							:					Dict       =	"""Spiderman is surfing"""
						A__							:					Union[str, Any]       =	torch.Generator(device="""cpu"""    ).manual_seed(0    )

						A__							:					Optional[int]       =	pipe(A__					, generator=A__					, num_inference_steps=2					, output_type="""pt"""    ).frames
						A__							:					Optional[int]       =	video_frames.cpu().numpy()

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



