





'''simple docstring'''






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 			lowerCamelCase					:


					def    SCREAMING_SNAKE_CASE_		(					self	:  Optional[int]       ):





											'''simple docstring'''





											torch.manual_seed(0       )
											_snake_case:   Union[str, Any]  					=		TaEncoderModel.from_pretrained('hf-internal-testing/tiny-random-t5'       )

											torch.manual_seed(0       )
											_snake_case:   List[str]  					=		AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-t5'       )

											torch.manual_seed(0       )
											_snake_case:   Tuple  					=		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       )
											_snake_case:   List[Any]  					=		DDPMScheduler(
											    num_train_timesteps=10_00       ,     beta_schedule='squaredcos_cap_v2'       ,     beta_start=0.0_001       ,     beta_end=0.02       ,     thresholding=__snake_case       ,     dynamic_thresholding_ratio=0.95       ,     sample_max_value=1.0       ,     prediction_type='epsilon'       ,     variance_type='learned_range'       ,     )

											torch.manual_seed(0       )
											_snake_case:   List[str]  					=		IFWatermarker()

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


					def    SCREAMING_SNAKE_CASE_		(					self	:  Any       ):





											'''simple docstring'''





											torch.manual_seed(0       )
											_snake_case:   List[Any]  					=		TaEncoderModel.from_pretrained('hf-internal-testing/tiny-random-t5'       )

											torch.manual_seed(0       )
											_snake_case:   Optional[Any]  					=		AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-t5'       )

											torch.manual_seed(0       )
											_snake_case:   Any  					=		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       )
											_snake_case:   Any  					=		DDPMScheduler(
											    num_train_timesteps=10_00       ,     beta_schedule='squaredcos_cap_v2'       ,     beta_start=0.0_001       ,     beta_end=0.02       ,     thresholding=__snake_case       ,     dynamic_thresholding_ratio=0.95       ,     sample_max_value=1.0       ,     prediction_type='epsilon'       ,     variance_type='learned_range'       ,     )

											torch.manual_seed(0       )
											_snake_case:   Dict  					=		DDPMScheduler(
											    num_train_timesteps=10_00       ,     beta_schedule='squaredcos_cap_v2'       ,     beta_start=0.0_001       ,     beta_end=0.02       ,     )

											torch.manual_seed(0       )
											_snake_case:   str  					=		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    SCREAMING_SNAKE_CASE_		(					self	:  Dict       ):





											'''simple docstring'''





											_snake_case:   str  					=		self.get_dummy_components()
											_snake_case:   Dict  					=		self.pipeline_class(**__snake_case       )
											pipe.to(__snake_case       )
											pipe.set_progress_bar_config(disable=__snake_case       )

											_snake_case:   Tuple  					=		self.get_dummy_inputs(__snake_case       )

											_snake_case:   Tuple  					=		inputs['prompt']
											_snake_case:   str  					=		inputs['generator']
											_snake_case:   Dict  					=		inputs['num_inference_steps']
											_snake_case:   Optional[int]  					=		inputs['output_type']

											if "image" in inputs:
																	_snake_case:   Union[str, Any]  					=		inputs['image']
											else:
																	_snake_case:   List[str]  					=		None

											if "mask_image" in inputs:
																	_snake_case:   Union[str, Any]  					=		inputs['mask_image']
											else:
																	_snake_case:   Union[str, Any]  					=		None

											if "original_image" in inputs:
																	_snake_case:   List[Any]  					=		inputs['original_image']
											else:
																	_snake_case:   Optional[int]  					=		None

											_snake_case					,						_snake_case:   Union[str, Any]  					=		pipe.encode_prompt(__snake_case       )

											# inputs with prompt converted to embeddings
											_snake_case:   List[str]  					=		{
											    '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:
																	_snake_case:   Dict  					=		image

											if mask_image is not None:
																	_snake_case:   Optional[Any]  					=		mask_image

											if original_image is not None:
																	_snake_case:   Optional[int]  					=		original_image

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

											_snake_case:   Union[str, Any]  					=		pipe(**__snake_case       )[0]

											with tempfile.TemporaryDirectory() as tmpdir:
																	pipe.save_pretrained(__snake_case       )
																	_snake_case:   Dict  					=		self.pipeline_class.from_pretrained(__snake_case       )
																	pipe_loaded.to(__snake_case       )
																	pipe_loaded.set_progress_bar_config(disable=__snake_case       )

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

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

											_snake_case:   int  					=		self.get_dummy_inputs(__snake_case       )

											_snake_case:   List[Any]  					=		inputs['generator']
											_snake_case:   Optional[int]  					=		inputs['num_inference_steps']
											_snake_case:   Optional[Any]  					=		inputs['output_type']

											# inputs with prompt converted to embeddings
											_snake_case:   List[str]  					=		{
											    '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:
																	_snake_case:   Tuple  					=		image

											if mask_image is not None:
																	_snake_case:   Dict  					=		mask_image

											if original_image is not None:
																	_snake_case:   Dict  					=		original_image

											_snake_case:   Any  					=		pipe_loaded(**__snake_case       )[0]

											_snake_case:   Dict  					=		np.abs(to_np(__snake_case       ) - to_np(__snake_case       )       ).max()
											self.assertLess(__snake_case       ,     1e-4       )




					def    SCREAMING_SNAKE_CASE_		(					self	:  Any       ):





											'''simple docstring'''





											_snake_case:   List[Any]  					=		self.get_dummy_components()
											_snake_case:   Dict  					=		self.pipeline_class(**__snake_case       )
											pipe.to(__snake_case       )
											pipe.set_progress_bar_config(disable=__snake_case       )

											_snake_case:   int  					=		self.get_dummy_inputs(__snake_case       )
											_snake_case:   Optional[int]  					=		pipe(**__snake_case       )[0]

											with tempfile.TemporaryDirectory() as tmpdir:
																	pipe.save_pretrained(__snake_case       )
																	_snake_case:   str  					=		self.pipeline_class.from_pretrained(__snake_case       )
																	pipe_loaded.to(__snake_case       )
																	pipe_loaded.set_progress_bar_config(disable=__snake_case       )

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

											_snake_case:   Any  					=		self.get_dummy_inputs(__snake_case       )
											_snake_case:   Optional[int]  					=		pipe_loaded(**__snake_case       )[0]

											_snake_case:   Tuple  					=		np.abs(to_np(__snake_case       ) - to_np(__snake_case       )       ).max()
											self.assertLess(__snake_case       ,     1e-4       )












'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available


A   : Dict             =			{'configuration_speech_encoder_decoder': ['SpeechEncoderDecoderConfig']}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		A   : int             =			['SpeechEncoderDecoderModel']

try:
		if not is_flax_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		A   : Union[str, Any]             =			['FlaxSpeechEncoderDecoderModel']

if TYPE_CHECKING:
		from .configuration_speech_encoder_decoder import SpeechEncoderDecoderConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_speech_encoder_decoder import SpeechEncoderDecoderModel

		try:
				if not is_flax_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_flax_speech_encoder_decoder import FlaxSpeechEncoderDecoderModel

else:
		import sys

		A   : int             =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





