



from dataclasses import dataclass
from typing import Optional

import torch
from torch import nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .attention import BasicTransformerBlock
from .modeling_utils import ModelMixin

@dataclass
class   _A   ( _snake_case	):


						'''simple docstring'''





						_snake_case			:     torch.FloatTensor

class   _A   ( _snake_case  ,						_snake_case	):


						'''simple docstring'''





						@register_to_config
						def __init__(	self	:							Optional[int]							,      lowerCamelCase	:							int = 16							,      lowerCamelCase	:							int = 88							,      lowerCamelCase	:							Optional[int] = None							,      lowerCamelCase	:							Optional[int] = None							,      lowerCamelCase	:							int = 1							,      lowerCamelCase	:							float = 0.0							,      lowerCamelCase	:							int = 32							,      lowerCamelCase	:							Optional[int] = None							,      lowerCamelCase	:							bool = False							,      lowerCamelCase	:							Optional[int] = None							,      lowerCamelCase	:							str = "geglu"							,      lowerCamelCase	:							bool = True							,      lowerCamelCase	:							bool = True							,      ):






							'''simple docstring'''



							super().__init__()
							__lowercase             =			num_attention_heads
							__lowercase             =			attention_head_dim
							__lowercase             =			num_attention_heads * attention_head_dim

							__lowercase             =			in_channels

							__lowercase             =			torch.nn.GroupNorm(num_groups=lowerCamelCase							,      num_channels=lowerCamelCase							,      eps=1e-6							,      affine=lowerCamelCase	)
							__lowercase             =			nn.Linear(lowerCamelCase							,      lowerCamelCase	)

							# 3. Define transformers blocks
							__lowercase             =			nn.ModuleList(
							    [
							        BasicTransformerBlock(
							            lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase							,      dropout=lowerCamelCase							,      cross_attention_dim=lowerCamelCase							,      activation_fn=lowerCamelCase							,      attention_bias=lowerCamelCase							,      double_self_attention=lowerCamelCase							,      norm_elementwise_affine=lowerCamelCase							,      )
							        for d in range(lowerCamelCase	)
							    ]	)

							__lowercase             =			nn.Linear(lowerCamelCase							,      lowerCamelCase	)



						def     _snake_case	(	self	:							Dict							,      lowerCamelCase	:							Tuple							,      lowerCamelCase	:							Optional[int]=None							,      lowerCamelCase	:							int=None							,      lowerCamelCase	:							Dict=None							,      lowerCamelCase	:							str=1							,      lowerCamelCase	:							int=None							,      lowerCamelCase	:							bool = True							,      ):






							'''simple docstring'''



							__lowercase       ,    __lowercase       ,    __lowercase       ,    __lowercase             =			hidden_states.shape
							__lowercase             =			batch_frames // num_frames

							__lowercase             =			hidden_states

							__lowercase             =			hidden_states[None, :].reshape(lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase	)
							__lowercase             =			hidden_states.permute(0							,      2							,      1							,      3							,      4	)

							__lowercase             =			self.norm(lowerCamelCase	)
							__lowercase             =			hidden_states.permute(0							,      3							,      4							,      2							,      1	).reshape(batch_size * height * width							,      lowerCamelCase							,      lowerCamelCase	)

							__lowercase             =			self.proj_in(lowerCamelCase	)

							# 2. Blocks
							for block in self.transformer_blocks:
								__lowercase             =			block(
								    lowerCamelCase							,      encoder_hidden_states=lowerCamelCase							,      timestep=lowerCamelCase							,      cross_attention_kwargs=lowerCamelCase							,      class_labels=lowerCamelCase							,      )

							# 3. Output
							__lowercase             =			self.proj_out(lowerCamelCase	)
							__lowercase             =			(
							    hidden_states[None, None, :]
							    .reshape(lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase	)
							    .permute(0							,      3							,      4							,      1							,      2	)
							    .contiguous()
							)
							__lowercase             =			hidden_states.reshape(lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase	)

							__lowercase             =			hidden_states + residual

							if not return_dict:
								return (output,)

							return TransformerTemporalModelOutput(sample=lowerCamelCase	)








import tempfile

import numpy as np
import torch
from transformers import AutoTokenizer, TaEncoderModel

from diffusers import DDPMScheduler, UNetaDConditionModel
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.pipelines.deepfloyd_if import IFWatermarker
from diffusers.utils.testing_utils import torch_device

from ..test_pipelines_common import to_np

class   _A   :


						'''simple docstring'''





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






							'''simple docstring'''



							torch.manual_seed(0	)
							__lowercase		       =			TaEncoderModel.from_pretrained("hf-internal-testing/tiny-random-t5"	)

							torch.manual_seed(0	)
							__lowercase		       =			AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-t5"	)

							torch.manual_seed(0	)
							__lowercase		       =			UNetaDConditionModel(
							    sample_size=32							,      layers_per_block=1							,      block_out_channels=[32, 64]							,      down_block_types=[
							        "ResnetDownsampleBlock2D",
							        "SimpleCrossAttnDownBlock2D",
							    ]							,      mid_block_type="UNetMidBlock2DSimpleCrossAttn"							,      up_block_types=["SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"]							,      in_channels=3							,      out_channels=6							,      cross_attention_dim=32							,      encoder_hid_dim=32							,      attention_head_dim=8							,      addition_embed_type="text"							,      addition_embed_type_num_heads=2							,      cross_attention_norm="group_norm"							,      resnet_time_scale_shift="scale_shift"							,      act_fn="gelu"							,      )
							unet.set_attn_processor(AttnAddedKVProcessor()	)  # For reproducibility tests

							torch.manual_seed(0	)
							__lowercase		       =			DDPMScheduler(
							    num_train_timesteps=1_000							,      beta_schedule="squaredcos_cap_v2"							,      beta_start=0.0001							,      beta_end=0.02							,      thresholding=lowerCamelCase							,      dynamic_thresholding_ratio=0.95							,      sample_max_value=1.0							,      prediction_type="epsilon"							,      variance_type="learned_range"							,      )

							torch.manual_seed(0	)
							__lowercase		       =			IFWatermarker()

							return {
							    "text_encoder": text_encoder,
							    "tokenizer": tokenizer,
							    "unet": unet,
							    "scheduler": scheduler,
							    "watermarker": watermarker,
							    "safety_checker": None,
							    "feature_extractor": None,
							}



						def     _snake_case	(	self	:							Tuple	):






							'''simple docstring'''



							torch.manual_seed(0	)
							__lowercase		       =			TaEncoderModel.from_pretrained("hf-internal-testing/tiny-random-t5"	)

							torch.manual_seed(0	)
							__lowercase		       =			AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-t5"	)

							torch.manual_seed(0	)
							__lowercase		       =			UNetaDConditionModel(
							    sample_size=32							,      layers_per_block=[1, 2]							,      block_out_channels=[32, 64]							,      down_block_types=[
							        "ResnetDownsampleBlock2D",
							        "SimpleCrossAttnDownBlock2D",
							    ]							,      mid_block_type="UNetMidBlock2DSimpleCrossAttn"							,      up_block_types=["SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"]							,      in_channels=6							,      out_channels=6							,      cross_attention_dim=32							,      encoder_hid_dim=32							,      attention_head_dim=8							,      addition_embed_type="text"							,      addition_embed_type_num_heads=2							,      cross_attention_norm="group_norm"							,      resnet_time_scale_shift="scale_shift"							,      act_fn="gelu"							,      class_embed_type="timestep"							,      mid_block_scale_factor=1.414							,      time_embedding_act_fn="gelu"							,      time_embedding_dim=32							,      )
							unet.set_attn_processor(AttnAddedKVProcessor()	)  # For reproducibility tests

							torch.manual_seed(0	)
							__lowercase		       =			DDPMScheduler(
							    num_train_timesteps=1_000							,      beta_schedule="squaredcos_cap_v2"							,      beta_start=0.0001							,      beta_end=0.02							,      thresholding=lowerCamelCase							,      dynamic_thresholding_ratio=0.95							,      sample_max_value=1.0							,      prediction_type="epsilon"							,      variance_type="learned_range"							,      )

							torch.manual_seed(0	)
							__lowercase		       =			DDPMScheduler(
							    num_train_timesteps=1_000							,      beta_schedule="squaredcos_cap_v2"							,      beta_start=0.0001							,      beta_end=0.02							,      )

							torch.manual_seed(0	)
							__lowercase		       =			IFWatermarker()

							return {
							    "text_encoder": text_encoder,
							    "tokenizer": tokenizer,
							    "unet": unet,
							    "scheduler": scheduler,
							    "image_noising_scheduler": image_noising_scheduler,
							    "watermarker": watermarker,
							    "safety_checker": None,
							    "feature_extractor": None,
							}



						def     _snake_case	(	self	:							str	):






							'''simple docstring'''



							__lowercase		       =			self.get_dummy_components()
							__lowercase		       =			self.pipeline_class(**lowerCamelCase	)
							pipe.to(lowerCamelCase	)
							pipe.set_progress_bar_config(disable=lowerCamelCase	)

							__lowercase		       =			self.get_dummy_inputs(lowerCamelCase	)

							__lowercase		       =			inputs["prompt"]
							__lowercase		       =			inputs["generator"]
							__lowercase		       =			inputs["num_inference_steps"]
							__lowercase		       =			inputs["output_type"]

							if "image" in inputs:
								__lowercase		       =			inputs["image"]
							else:
								__lowercase		       =			None

							if "mask_image" in inputs:
								__lowercase		       =			inputs["mask_image"]
							else:
								__lowercase		       =			None

							if "original_image" in inputs:
								__lowercase		       =			inputs["original_image"]
							else:
								__lowercase		       =			None

							__lowercase       ,    __lowercase		       =			pipe.encode_prompt(lowerCamelCase	)

							# inputs with prompt converted to embeddings
							__lowercase		       =			{
							    "prompt_embeds": prompt_embeds,
							    "negative_prompt_embeds": negative_prompt_embeds,
							    "generator": generator,
							    "num_inference_steps": num_inference_steps,
							    "output_type": output_type,
							}

							if image is not None:
								__lowercase		       =			image

							if mask_image is not None:
								__lowercase		       =			mask_image

							if original_image is not None:
								__lowercase		       =			original_image

							# set all optional components to None
							for optional_component in pipe._optional_components:
								setattr(lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase	)

							__lowercase		       =			pipe(**lowerCamelCase	)[0]

							with tempfile.TemporaryDirectory() as tmpdir:
								pipe.save_pretrained(lowerCamelCase	)
								__lowercase		       =			self.pipeline_class.from_pretrained(lowerCamelCase	)
								pipe_loaded.to(lowerCamelCase	)
								pipe_loaded.set_progress_bar_config(disable=lowerCamelCase	)

							pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor()	)  # For reproducibility tests

							for optional_component in pipe._optional_components:
								self.assertTrue(
								    getattr(lowerCamelCase							,      lowerCamelCase	) is None							,      f"""`{optional_component}` did not stay set to None after loading."""							,      )

							__lowercase		       =			self.get_dummy_inputs(lowerCamelCase	)

							__lowercase		       =			inputs["generator"]
							__lowercase		       =			inputs["num_inference_steps"]
							__lowercase		       =			inputs["output_type"]

							# inputs with prompt converted to embeddings
							__lowercase		       =			{
							    "prompt_embeds": prompt_embeds,
							    "negative_prompt_embeds": negative_prompt_embeds,
							    "generator": generator,
							    "num_inference_steps": num_inference_steps,
							    "output_type": output_type,
							}

							if image is not None:
								__lowercase		       =			image

							if mask_image is not None:
								__lowercase		       =			mask_image

							if original_image is not None:
								__lowercase		       =			original_image

							__lowercase		       =			pipe_loaded(**lowerCamelCase	)[0]

							__lowercase		       =			np.abs(to_np(lowerCamelCase	) - to_np(lowerCamelCase	)	).max()
							self.assertLess(lowerCamelCase							,      1e-4	)



						def     _snake_case	(	self	:							Optional[Any]	):






							'''simple docstring'''



							__lowercase		       =			self.get_dummy_components()
							__lowercase		       =			self.pipeline_class(**lowerCamelCase	)
							pipe.to(lowerCamelCase	)
							pipe.set_progress_bar_config(disable=lowerCamelCase	)

							__lowercase		       =			self.get_dummy_inputs(lowerCamelCase	)
							__lowercase		       =			pipe(**lowerCamelCase	)[0]

							with tempfile.TemporaryDirectory() as tmpdir:
								pipe.save_pretrained(lowerCamelCase	)
								__lowercase		       =			self.pipeline_class.from_pretrained(lowerCamelCase	)
								pipe_loaded.to(lowerCamelCase	)
								pipe_loaded.set_progress_bar_config(disable=lowerCamelCase	)

							pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor()	)  # For reproducibility tests

							__lowercase		       =			self.get_dummy_inputs(lowerCamelCase	)
							__lowercase		       =			pipe_loaded(**lowerCamelCase	)[0]

							__lowercase		       =			np.abs(to_np(lowerCamelCase	) - to_np(lowerCamelCase	)	).max()
							self.assertLess(lowerCamelCase							,      1e-4	)



