





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       (  a      ):
				UpperCAmelCase_								=			42




class  __A       (  a      ,   a      ):


				@register_to_config
				def __init__(						self				,	UpperCAmelCase_ = 16				,	UpperCAmelCase_ = 88				,	UpperCAmelCase_ = None				,	UpperCAmelCase_ = None				,	UpperCAmelCase_ = 1				,	UpperCAmelCase_ = 0.0				,	UpperCAmelCase_ = 32				,	UpperCAmelCase_ = None				,	UpperCAmelCase_ = False				,	UpperCAmelCase_ = None				,	UpperCAmelCase_ = "geglu"				,	UpperCAmelCase_ = True				,	UpperCAmelCase_ = True				,	):
								super().__init__()
								lowerCamelCase			=num_attention_heads
								lowerCamelCase			=attention_head_dim
								lowerCamelCase			=num_attention_heads * attention_head_dim

								lowerCamelCase			=in_channels

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

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

								lowerCamelCase			=nn.Linear(UpperCAmelCase_				,	UpperCAmelCase_							)


				def _snake_case    (						self				,	UpperCAmelCase_				,	UpperCAmelCase_=None				,	UpperCAmelCase_=None				,	UpperCAmelCase_=None				,	UpperCAmelCase_=1				,	UpperCAmelCase_=None				,	UpperCAmelCase_ = True				,	):
								lowerCamelCase	,					lowerCamelCase	,					lowerCamelCase	,					lowerCamelCase			=hidden_states.shape
								lowerCamelCase			=batch_frames // num_frames

								lowerCamelCase			=hidden_states

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

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

								lowerCamelCase			=self.proj_in(UpperCAmelCase_							)

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

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

								lowerCamelCase			=hidden_states + residual

								if not return_dict:
												return (output,)

								return TransformerTemporalModelOutput(sample=UpperCAmelCase_							)












import random
import unittest

import torch

from diffusers import IFInpaintingSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin

@skip_mps
class  __A       (  a      ,   a      ,   unittest.TestCase      ):
				__A								=			IFInpaintingSuperResolutionPipeline
				__A								=			TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"""width""", """height"""}
				__A								=			TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS.union({"""original_image"""}      )
				__A								=			PipelineTesterMixin.required_optional_params - {"""latents"""}


				def _snake_case    (						self							):
								return self._get_superresolution_dummy_components()


				def _snake_case    (						self				,	UpperCAmelCase_				,	UpperCAmelCase_=0							):
								if str(UpperCAmelCase_							).startswith("""mps"""							):
												lowerCamelCase			=torch.manual_seed(UpperCAmelCase_							)
								else:
												lowerCamelCase			=torch.Generator(device=UpperCAmelCase_							).manual_seed(UpperCAmelCase_							)

								lowerCamelCase			=floats_tensor((1, 3, 16, 16)				,	rng=random.Random(UpperCAmelCase_							)							).to(UpperCAmelCase_							)
								lowerCamelCase			=floats_tensor((1, 3, 32, 32)				,	rng=random.Random(UpperCAmelCase_							)							).to(UpperCAmelCase_							)
								lowerCamelCase			=floats_tensor((1, 3, 32, 32)				,	rng=random.Random(UpperCAmelCase_							)							).to(UpperCAmelCase_							)

								lowerCamelCase			={
								    """prompt""": """A painting of a squirrel eating a burger""",
								    """image""": image,
								    """original_image""": original_image,
								    """mask_image""": mask_image,
								    """generator""": generator,
								    """num_inference_steps""": 2,
								    """output_type""": """numpy""",
								}

								return inputs


				@unittest.skipIf(
				    torch_device != """cuda""" or not is_xformers_available()				,	reason="""XFormers attention is only available with CUDA and `xformers` installed"""				,	)
				def _snake_case    (						self							):
								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3							)


				def _snake_case    (						self							):
								self._test_save_load_optional_components()


				@unittest.skipIf(torch_device != """cuda"""				,	reason="""float16 requires CUDA"""							)
				def _snake_case    (						self							):
								# Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
								super().test_save_load_floataa(expected_max_diff=1E-1							)


				def _snake_case    (						self							):
								self._test_attention_slicing_forward_pass(expected_max_diff=1E-2							)


				def _snake_case    (						self							):
								self._test_save_load_local()


				def _snake_case    (						self							):
								self._test_inference_batch_single_identical(
								    expected_max_diff=1E-2				,	)





