






import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()



class 				__UpperCAmelCase		(_UpperCAmelCase	,_UpperCAmelCase	,_UpperCAmelCase	,unittest.TestCase   ):
			__snake_case    :				int									=							StableUnCLIPPipeline
			__snake_case    :				Optional[int]									=							TEXT_TO_IMAGE_PARAMS
			__snake_case    :				int									=							TEXT_TO_IMAGE_BATCH_PARAMS
			__snake_case    :				Dict									=							TEXT_TO_IMAGE_IMAGE_PARAMS
			__snake_case    :				Dict									=							TEXT_TO_IMAGE_IMAGE_PARAMS

			# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
			__snake_case    :				Tuple									=							False







			def 							UpperCamelCase				(     self:  Tuple					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  32
									_SCREAMING_SNAKE_CASE     				=  embedder_hidden_size

									# prior components

									torch.manual_seed(0					)
									_SCREAMING_SNAKE_CASE     				=  CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)

									torch.manual_seed(0					)
									_SCREAMING_SNAKE_CASE     				=  CLIPTextModelWithProjection(
									    CLIPTextConfig(
									        bos_token_id=0				,     eos_token_id=2				,     hidden_size=UpperCAmelCase_				,     projection_dim=UpperCAmelCase_				,     intermediate_size=37				,     layer_norm_eps=1E-05				,     num_attention_heads=4				,     num_hidden_layers=5				,     pad_token_id=1				,     vocab_size=1_000				,     )					)

									torch.manual_seed(0					)
									_SCREAMING_SNAKE_CASE     				=  PriorTransformer(
									    num_attention_heads=2				,     attention_head_dim=12				,     embedding_dim=UpperCAmelCase_				,     num_layers=1				,     )

									torch.manual_seed(0					)
									_SCREAMING_SNAKE_CASE     				=  DDPMScheduler(
									    variance_type="""fixed_small_log"""				,     prediction_type="""sample"""				,     num_train_timesteps=1_000				,     clip_sample=UpperCAmelCase_				,     clip_sample_range=5.0				,     beta_schedule="""squaredcos_cap_v2"""				,     )

									# regular denoising components

									torch.manual_seed(0					)
									_SCREAMING_SNAKE_CASE     				=  StableUnCLIPImageNormalizer(embedding_dim=UpperCAmelCase_					)
									_SCREAMING_SNAKE_CASE     				=  DDPMScheduler(beta_schedule="""squaredcos_cap_v2"""					)

									torch.manual_seed(0					)
									_SCREAMING_SNAKE_CASE     				=  CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)

									torch.manual_seed(0					)
									_SCREAMING_SNAKE_CASE     				=  CLIPTextModel(
									    CLIPTextConfig(
									        bos_token_id=0				,     eos_token_id=2				,     hidden_size=UpperCAmelCase_				,     projection_dim=32				,     intermediate_size=37				,     layer_norm_eps=1E-05				,     num_attention_heads=4				,     num_hidden_layers=5				,     pad_token_id=1				,     vocab_size=1_000				,     )					)

									torch.manual_seed(0					)
									_SCREAMING_SNAKE_CASE     				=  UNetaDConditionModel(
									    sample_size=32				,     in_channels=4				,     out_channels=4				,     down_block_types=("""CrossAttnDownBlock2D""", """DownBlock2D""")				,     up_block_types=("""UpBlock2D""", """CrossAttnUpBlock2D""")				,     block_out_channels=(32, 64)				,     attention_head_dim=(2, 4)				,     class_embed_type="""projection"""				,     projection_class_embeddings_input_dim=embedder_projection_dim * 2				,     cross_attention_dim=UpperCAmelCase_				,     layers_per_block=1				,     upcast_attention=UpperCAmelCase_				,     use_linear_projection=UpperCAmelCase_				,     )

									torch.manual_seed(0					)
									_SCREAMING_SNAKE_CASE     				=  DDIMScheduler(
									    beta_schedule="""scaled_linear"""				,     beta_start=0.0_00_85				,     beta_end=0.0_12				,     prediction_type="""v_prediction"""				,     set_alpha_to_one=UpperCAmelCase_				,     steps_offset=1				,     )

									torch.manual_seed(0					)
									_SCREAMING_SNAKE_CASE     				=  AutoencoderKL()

									_SCREAMING_SNAKE_CASE     				=  {
									    # prior components
									    """prior_tokenizer""": prior_tokenizer,
									    """prior_text_encoder""": prior_text_encoder,
									    """prior""": prior,
									    """prior_scheduler""": prior_scheduler,
									    # image noising components
									    """image_normalizer""": image_normalizer,
									    """image_noising_scheduler""": image_noising_scheduler,
									    # regular denoising components
									    """tokenizer""": tokenizer,
									    """text_encoder""": text_encoder,
									    """unet""": unet,
									    """scheduler""": scheduler,
									    """vae""": vae,
									}

									return components







			def 							UpperCamelCase				(     self:  str				,     UpperCAmelCase_:  int				,     UpperCAmelCase_:  Tuple=0					):







									'''simple docstring'''




									if str(UpperCAmelCase_					).startswith("""mps"""					):
															_SCREAMING_SNAKE_CASE     				=  torch.manual_seed(UpperCAmelCase_					)
									else:
															_SCREAMING_SNAKE_CASE     				=  torch.Generator(device=UpperCAmelCase_					).manual_seed(UpperCAmelCase_					)
									_SCREAMING_SNAKE_CASE     				=  {
									    """prompt""": """A painting of a squirrel eating a burger""",
									    """generator""": generator,
									    """num_inference_steps""": 2,
									    """prior_num_inference_steps""": 2,
									    """output_type""": """numpy""",
									}
									return inputs







			def 							UpperCamelCase				(     self:  str					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  torch_device == """cpu"""

									self._test_attention_slicing_forward_pass(test_max_difference=UpperCAmelCase_					)







			def 							UpperCamelCase				(     self:  Tuple					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  torch_device in ["""cpu""", """mps"""]

									self._test_inference_batch_single_identical(test_max_difference=UpperCAmelCase_					)



@slow
@require_torch_gpu
class 				__UpperCAmelCase		(unittest.TestCase   ):







			def 							UpperCamelCase				(     self:  str					):







									'''simple docstring'''




									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()







			def 							UpperCamelCase				(     self:  str					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  load_numpy(
									    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy"""					)

									_SCREAMING_SNAKE_CASE     				=  StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""				,     torch_dtype=torch.floataa					)
									pipe.to(UpperCAmelCase_					)
									pipe.set_progress_bar_config(disable=UpperCAmelCase_					)
									# stable unclip will oom when integration tests are run on a V100,
									# so turn on memory savings
									pipe.enable_attention_slicing()
									pipe.enable_sequential_cpu_offload()

									_SCREAMING_SNAKE_CASE     				=  torch.Generator(device="""cpu"""					).manual_seed(0					)
									_SCREAMING_SNAKE_CASE     				=  pipe("""anime turle"""				,     generator=UpperCAmelCase_				,     output_type="""np"""					)

									_SCREAMING_SNAKE_CASE     				=  output.images[0]

									assert image.shape == (768, 768, 3)

									assert_mean_pixel_difference(UpperCAmelCase_				,     UpperCAmelCase_					)







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







									'''simple docstring'''




									torch.cuda.empty_cache()
									torch.cuda.reset_max_memory_allocated()
									torch.cuda.reset_peak_memory_stats()

									_SCREAMING_SNAKE_CASE     				=  StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""				,     torch_dtype=torch.floataa					)
									_SCREAMING_SNAKE_CASE     				=  pipe.to(UpperCAmelCase_					)
									pipe.set_progress_bar_config(disable=UpperCAmelCase_					)
									pipe.enable_attention_slicing()
									pipe.enable_sequential_cpu_offload()

									_SCREAMING_SNAKE_CASE     				=  pipe(
									    """anime turtle"""				,     prior_num_inference_steps=2				,     num_inference_steps=2				,     output_type="""np"""				,     )

									_SCREAMING_SNAKE_CASE     				=  torch.cuda.max_memory_allocated()
									# make sure that less than 7 GB is allocated
									assert mem_bytes < 7 * 10**9









from typing import TYPE_CHECKING

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


UpperCamelCase			    =     {
    '''configuration_layoutlmv3''': [
        '''LAYOUTLMV3_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''LayoutLMv3Config''',
        '''LayoutLMv3OnnxConfig''',
    ],
    '''processing_layoutlmv3''': ['''LayoutLMv3Processor'''],
    '''tokenization_layoutlmv3''': ['''LayoutLMv3Tokenizer'''],
}

try:
		if not is_tokenizers_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCamelCase			    =     ['''LayoutLMv3TokenizerFast''']

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCamelCase			    =     [
		    '''LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''LayoutLMv3ForQuestionAnswering''',
		    '''LayoutLMv3ForSequenceClassification''',
		    '''LayoutLMv3ForTokenClassification''',
		    '''LayoutLMv3Model''',
		    '''LayoutLMv3PreTrainedModel''',
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCamelCase			    =     [
		    '''TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''TFLayoutLMv3ForQuestionAnswering''',
		    '''TFLayoutLMv3ForSequenceClassification''',
		    '''TFLayoutLMv3ForTokenClassification''',
		    '''TFLayoutLMv3Model''',
		    '''TFLayoutLMv3PreTrainedModel''',
		]

try:
		if not is_vision_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCamelCase			    =     ['''LayoutLMv3FeatureExtractor''']
		UpperCamelCase			    =     ['''LayoutLMv3ImageProcessor''']


if TYPE_CHECKING:
		from .configuration_layoutlmva import (
		    LAYOUTLMV3_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    LayoutLMvaConfig,
		    LayoutLMvaOnnxConfig,
		)
		from .processing_layoutlmva import LayoutLMvaProcessor
		from .tokenization_layoutlmva import LayoutLMvaTokenizer

		try:
				if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .tokenization_layoutlmva_fast import LayoutLMvaTokenizerFast

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_layoutlmva import (
				    LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
				    LayoutLMvaForQuestionAnswering,
				    LayoutLMvaForSequenceClassification,
				    LayoutLMvaForTokenClassification,
				    LayoutLMvaModel,
				    LayoutLMvaPreTrainedModel,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_layoutlmva import (
				    TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFLayoutLMvaForQuestionAnswering,
				    TFLayoutLMvaForSequenceClassification,
				    TFLayoutLMvaForTokenClassification,
				    TFLayoutLMvaModel,
				    TFLayoutLMvaPreTrainedModel,
				)

		try:
				if not is_vision_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .feature_extraction_layoutlmva import LayoutLMvaFeatureExtractor
				from .image_processing_layoutlmva import LayoutLMvaImageProcessor

else:
		import sys

		UpperCamelCase			    =     _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

