

'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCAmelCase_     =      {"configuration_pegasus": ["PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP", "PegasusConfig"]}

try:
						if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase_     =      ["PegasusTokenizer"]

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase_     =      ["PegasusTokenizerFast"]

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase_     =      [
						    "PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST",
						    "PegasusForCausalLM",
						    "PegasusForConditionalGeneration",
						    "PegasusModel",
						    "PegasusPreTrainedModel",
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase_     =      [
						    "TFPegasusForConditionalGeneration",
						    "TFPegasusModel",
						    "TFPegasusPreTrainedModel",
						]

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase_     =      [
						    "FlaxPegasusForConditionalGeneration",
						    "FlaxPegasusModel",
						    "FlaxPegasusPreTrainedModel",
						]


if TYPE_CHECKING:
						from .configuration_pegasus import PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP, PegasusConfig

						try:
												if not is_sentencepiece_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_pegasus import PegasusTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_pegasus_fast import PegasusTokenizerFast

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_pegasus import (
												    PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST,
												    PegasusForCausalLM,
												    PegasusForConditionalGeneration,
												    PegasusModel,
												    PegasusPreTrainedModel,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_pegasus import TFPegasusForConditionalGeneration, TFPegasusModel, TFPegasusPreTrainedModel

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_pegasus import (
												    FlaxPegasusForConditionalGeneration,
												    FlaxPegasusModel,
												    FlaxPegasusPreTrainedModel,
												)

else:
						import sys

						lowerCAmelCase_     =      _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)








'''simple docstring'''

import tempfile
import unittest

import numpy as np
import torch

from diffusers import DiffusionPipeline
from diffusers.models.attention_processor import Attention, AttnAddedKVProcessor







class lowerCamelCase   (    unittest.TestCase				):

				def 					_lowerCamelCase    (       self,						lowercase_ = False )    ->							Union[str, Any]:
					snake_case							=					10

					if only_cross_attention:
						snake_case							=					12
					else:
						# when only cross attention is not set, the cross attention dim must be the same as the query dim
						snake_case							=					query_dim

					return {
					    "query_dim": query_dim,
					    "cross_attention_dim": cross_attention_dim,
					    "heads": 2,
					    "dim_head": 4,
					    "added_kv_proj_dim": 6,
					    "norm_num_groups": 1,
					    "only_cross_attention": only_cross_attention,
					    "processor": AttnAddedKVProcessor(),
					}

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_ )    ->							Optional[int]:
					snake_case							=					2

					snake_case							=					torch.rand(lowercase_,						lowercase_,						3,						2 )
					snake_case							=					torch.rand(lowercase_,						4,						lowercase_ )
					snake_case							=					None

					return {
					    "hidden_states": hidden_states,
					    "encoder_hidden_states": encoder_hidden_states,
					    "attention_mask": attention_mask,
					}






				def 					_lowerCamelCase    (       self )    ->							str:
					# self and cross attention

					torch.manual_seed(0 )

					snake_case							=					self.get_constructor_arguments(only_cross_attention=lowercase_ )
					snake_case							=					Attention(**lowercase_ )

					self.assertTrue(attn.to_k is not None )
					self.assertTrue(attn.to_v is not None )

					snake_case							=					self.get_forward_arguments(
					    query_dim=constructor_args['query_dim'],						added_kv_proj_dim=constructor_args['added_kv_proj_dim'] )

					snake_case							=					attn(**lowercase_ )

					# only self attention

					torch.manual_seed(0 )

					snake_case							=					self.get_constructor_arguments(only_cross_attention=lowercase_ )
					snake_case							=					Attention(**lowercase_ )

					self.assertTrue(attn.to_k is None )
					self.assertTrue(attn.to_v is None )

					snake_case							=					self.get_forward_arguments(
					    query_dim=constructor_args['query_dim'],						added_kv_proj_dim=constructor_args['added_kv_proj_dim'] )

					snake_case							=					attn(**lowercase_ )

					self.assertTrue((only_cross_attn_out != self_and_cross_attn_out).all() )







class lowerCamelCase   (    unittest.TestCase				):

				def 					_lowerCamelCase    (       self )    ->							List[Any]:
					snake_case							=					DiffusionPipeline.from_pretrained('hf-internal-testing/tiny-stable-diffusion-pipe',						safety_checker=lowercase_ )

					snake_case							=					pipe(
					    'foo',						num_inference_steps=2,						generator=torch.Generator('cpu' ).manual_seed(0 ),						output_type='np',						).images

					# the initial conversion succeeds
					snake_case							=					DiffusionPipeline.from_pretrained(
					    'hf-internal-testing/tiny-stable-diffusion-pipe',						device_map='sequential',						safety_checker=lowercase_ )

					snake_case							=					pipe(
					    'foo',						num_inference_steps=2,						generator=torch.Generator('cpu' ).manual_seed(0 ),						output_type='np',						).images

					with tempfile.TemporaryDirectory() as tmpdir:
						# save the converted model
						pipe.save_pretrained(lowercase_ )

						# can also load the converted weights
						snake_case							=					DiffusionPipeline.from_pretrained(lowercase_,						device_map='sequential',						safety_checker=lowercase_ )

					snake_case							=					pipe(
					    'foo',						num_inference_steps=2,						generator=torch.Generator('cpu' ).manual_seed(0 ),						output_type='np',						).images

					self.assertTrue(np.allclose(lowercase_,						lowercase_,						atol=1E-5 ) )
					self.assertTrue(np.allclose(lowercase_,						lowercase_,						atol=1E-5 ) )





