
import unittest

from transformers import TrOCRConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers.models.trocr.modeling_trocr import TrOCRDecoder, TrOCRForCausalLM




@require_torch
class        _SCREAMING_SNAKE_CASE	:



	def __init__(       self		,    lowercase		,    lowercase=99		,    lowercase=13		,    lowercase=16		,    lowercase=7		,    lowercase=True		,    lowercase=True		,    lowercase=True		,    lowercase=False		,    lowercase=True		,    lowercase=2		,    lowercase=32		,    lowercase=4		,    lowercase=4		,    lowercase=30		,    lowercase=0		,    lowercase=1		,    lowercase=2		,    lowercase=None		,    )							->			Optional[int]:
					lowerCamelCase_         =     parent
					lowerCamelCase_         =     batch_size
					lowerCamelCase_         =     decoder_seq_length
					# For common tests
					lowerCamelCase_         =     self.decoder_seq_length
					lowerCamelCase_         =     is_training
					lowerCamelCase_         =     use_attention_mask
					lowerCamelCase_         =     use_labels

					lowerCamelCase_         =     vocab_size
					lowerCamelCase_         =     d_model
					lowerCamelCase_         =     d_model
					lowerCamelCase_         =     decoder_layers
					lowerCamelCase_         =     decoder_layers
					lowerCamelCase_         =     decoder_ffn_dim
					lowerCamelCase_         =     decoder_attention_heads
					lowerCamelCase_         =     decoder_attention_heads
					lowerCamelCase_         =     eos_token_id
					lowerCamelCase_         =     bos_token_id
					lowerCamelCase_         =     pad_token_id
					lowerCamelCase_         =     decoder_start_token_id
					lowerCamelCase_         =     use_cache
					lowerCamelCase_         =     max_position_embeddings

					lowerCamelCase_         =     None
					lowerCamelCase_         =     decoder_seq_length
					lowerCamelCase_         =     2
					lowerCamelCase_         =     1



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Any:
					lowerCamelCase_         =     ids_tensor([self.batch_size, self.decoder_seq_length]		,    self.vocab_size					)

					lowerCamelCase_         =     None
					if self.use_attention_mask:
									lowerCamelCase_         =     ids_tensor([self.batch_size, self.decoder_seq_length]		,    vocab_size=2					)

					lowerCamelCase_         =     None
					if self.use_labels:
									lowerCamelCase_         =     ids_tensor([self.batch_size, self.decoder_seq_length]		,    self.vocab_size					)

					lowerCamelCase_         =     TrOCRConfig(
					    vocab_size=self.vocab_size		,    d_model=self.d_model		,    decoder_layers=self.decoder_layers		,    decoder_ffn_dim=self.decoder_ffn_dim		,    decoder_attention_heads=self.decoder_attention_heads		,    eos_token_id=self.eos_token_id		,    bos_token_id=self.bos_token_id		,    use_cache=self.use_cache		,    pad_token_id=self.pad_token_id		,    decoder_start_token_id=self.decoder_start_token_id		,    max_position_embeddings=self.max_position_embeddings		,    )

					return (config, input_ids, attention_mask, lm_labels)



	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase		,    lowercase		,    lowercase		,    )							->			Any:
					lowerCamelCase_         =     True
					lowerCamelCase_         =     TrOCRDecoder(config=lowercase					).to(lowercase					).eval()
					lowerCamelCase_         =     input_ids[:2]

					input_ids[input_ids == 0] += 1
					# first forward pass
					lowerCamelCase_         =     model(lowercase		,    use_cache=lowercase					)
					lowerCamelCase_         =     model(lowercase					)
					lowerCamelCase_         =     model(lowercase		,    use_cache=lowercase					)

					self.parent.assertTrue(len(lowercase					) == len(lowercase					)					)
					self.parent.assertTrue(len(lowercase					) == len(lowercase					) + 1					)

					lowerCamelCase_         =     outputs["past_key_values"]

					# create hypothetical next token and extent to next_input_ids
					lowerCamelCase_         =     ids_tensor((2, 1)		,    config.vocab_size - 1					) + 1

					# append to next input_ids and
					lowerCamelCase_         =     torch.cat([input_ids, next_tokens]		,    dim=-1					)

					lowerCamelCase_         =     model(lowercase					)["last_hidden_state"]
					lowerCamelCase_         =     model(lowercase		,    past_key_values=lowercase					)["last_hidden_state"]

					# select random slice
					lowerCamelCase_         =     ids_tensor((1,)		,    output_from_past.shape[-1]					).item()
					lowerCamelCase_         =     output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
					lowerCamelCase_         =     output_from_past[:, 0, random_slice_idx].detach()

					# test that outputs are equal for slice
					assert torch.allclose(lowercase		,    lowercase		,    atol=1e-3					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			int:
					lowerCamelCase_         =     self.prepare_config_and_inputs()
					lowerCamelCase_      ,       lowerCamelCase_      ,       lowerCamelCase_      ,       lowerCamelCase_         =     config_and_inputs

					lowerCamelCase_         =     {"input_ids": input_ids, "attention_mask": attention_mask}
					return config, inputs_dict




@require_torch
class        _SCREAMING_SNAKE_CASE	( snake_case_     ,			snake_case_     ,			snake_case_     ,			unittest.TestCase		):
	lowerCAmelCase__   =					(TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
	lowerCAmelCase__   =					(TrOCRForCausalLM,) if is_torch_available() else ()
	lowerCAmelCase__   =					{'text-generation': TrOCRForCausalLM} if is_torch_available() else {}
	lowerCAmelCase__   =					True
	lowerCAmelCase__   =					False



	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[str]:
					lowerCamelCase_         =     TrOCRStandaloneDecoderModelTester(self		,    is_training=lowercase					)
					lowerCamelCase_         =     ConfigTester(self		,    config_class=lowercase					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[Any]:
					pass



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[int]:
					pass



	def        SCREAMING_SNAKE_CASE_(       self					)							->			str:
					pass



	def        SCREAMING_SNAKE_CASE_(       self					)							->			int:
					self.config_tester.run_common_tests()



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[int]:
					lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_decoder_model_past(*lowercase					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[Any]:
					return



	@unittest.skip("The model doesn't support left padding"					)  # and it's not used enough to be worth fixing :)
	def        SCREAMING_SNAKE_CASE_(       self					)							->			str:
					pass




# This model implementation is heavily inspired by https://github.com/haofanwang/ControlNet-for-Diffusers/

import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()




class        _SCREAMING_SNAKE_CASE	( snake_case_     ,			snake_case_     ,			snake_case_     ,			unittest.TestCase		):
	lowerCAmelCase__   =					StableDiffusionControlNetImgaImgPipeline
	lowerCAmelCase__   =					TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'height', 'width'}
	lowerCAmelCase__   =					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
	lowerCAmelCase__   =					IMAGE_TO_IMAGE_IMAGE_PARAMS.union({'control_image'}		)
	lowerCAmelCase__   =					IMAGE_TO_IMAGE_IMAGE_PARAMS



	def        SCREAMING_SNAKE_CASE_(       self					)							->			int:
					torch.manual_seed(0					)
					lowerCamelCase_         =     UNetaDConditionModel(
					    block_out_channels=(32, 64)		,    layers_per_block=2		,    sample_size=32		,    in_channels=4		,    out_channels=4		,    down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")		,    up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")		,    cross_attention_dim=32		,    )
					torch.manual_seed(0					)
					lowerCamelCase_         =     ControlNetModel(
					    block_out_channels=(32, 64)		,    layers_per_block=2		,    in_channels=4		,    down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")		,    cross_attention_dim=32		,    conditioning_embedding_out_channels=(16, 32)		,    )
					torch.manual_seed(0					)
					lowerCamelCase_         =     DDIMScheduler(
					    beta_start=0.0_0_0_8_5		,    beta_end=0.0_1_2		,    beta_schedule="scaled_linear"		,    clip_sample=lowercase		,    set_alpha_to_one=lowercase		,    )
					torch.manual_seed(0					)
					lowerCamelCase_         =     AutoencoderKL(
					    block_out_channels=[32, 64]		,    in_channels=3		,    out_channels=3		,    down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]		,    up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]		,    latent_channels=4		,    )
					torch.manual_seed(0					)
					lowerCamelCase_         =     CLIPTextConfig(
					    bos_token_id=0		,    eos_token_id=2		,    hidden_size=32		,    intermediate_size=37		,    layer_norm_eps=1e-05		,    num_attention_heads=4		,    num_hidden_layers=5		,    pad_token_id=1		,    vocab_size=1000		,    )
					lowerCamelCase_         =     CLIPTextModel(lowercase					)
					lowerCamelCase_         =     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"					)

					lowerCamelCase_         =     {
					    "unet": unet,
					    "controlnet": controlnet,
					    "scheduler": scheduler,
					    "vae": vae,
					    "text_encoder": text_encoder,
					    "tokenizer": tokenizer,
					    "safety_checker": None,
					    "feature_extractor": None,
					}
					return components



	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase=0					)							->			int:
					if str(lowercase					).startswith("mps"					):
									lowerCamelCase_         =     torch.manual_seed(lowercase					)
					else:
									lowerCamelCase_         =     torch.Generator(device=lowercase					).manual_seed(lowercase					)

					lowerCamelCase_         =     2
					lowerCamelCase_         =     randn_tensor(
					    (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)		,    generator=lowercase		,    device=torch.device(lowercase					)		,    )
					lowerCamelCase_         =     floats_tensor(control_image.shape		,    rng=random.Random(lowercase					)					).to(lowercase					)
					lowerCamelCase_         =     image.cpu().permute(0		,    2		,    3		,    1					)[0]
					lowerCamelCase_         =     Image.fromarray(np.uinta(lowercase					)					).convert("RGB"					).resize((64, 64)					)
					lowerCamelCase_         =     {
					    "prompt": "A painting of a squirrel eating a burger",
					    "generator": generator,
					    "num_inference_steps": 2,
					    "guidance_scale": 6.0,
					    "output_type": "numpy",
					    "image": image,
					    "control_image": control_image,
					}

					return inputs



	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[str]:
					return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3					)



	@unittest.skipIf(
	    torch_device != "cuda" or not is_xformers_available()		,    reason="XFormers attention is only available with CUDA and `xformers` installed"		,    )
	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[str]:
					self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Any:
					self._test_inference_batch_single_identical(expected_max_diff=2e-3					)




class        _SCREAMING_SNAKE_CASE	( snake_case_     ,			snake_case_     ,			unittest.TestCase		):
	lowerCAmelCase__   =					StableDiffusionControlNetImgaImgPipeline
	lowerCAmelCase__   =					TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'height', 'width'}
	lowerCAmelCase__   =					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
	lowerCAmelCase__   =					frozenset([]		)  # TO_DO: add image_params once refactored VaeImageProcessor.preprocess



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Dict:
					torch.manual_seed(0					)
					lowerCamelCase_         =     UNetaDConditionModel(
					    block_out_channels=(32, 64)		,    layers_per_block=2		,    sample_size=32		,    in_channels=4		,    out_channels=4		,    down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")		,    up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")		,    cross_attention_dim=32		,    )
					torch.manual_seed(0					)

					def init_weights(lowercase					):
									if isinstance(lowercase		,    torch.nn.Convad					):
													torch.nn.init.normal(m.weight					)
													m.bias.data.fill_(1.0					)

					lowerCamelCase_         =     ControlNetModel(
					    block_out_channels=(32, 64)		,    layers_per_block=2		,    in_channels=4		,    down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")		,    cross_attention_dim=32		,    conditioning_embedding_out_channels=(16, 32)		,    )
					controlneta.controlnet_down_blocks.apply(lowercase					)

					torch.manual_seed(0					)
					lowerCamelCase_         =     ControlNetModel(
					    block_out_channels=(32, 64)		,    layers_per_block=2		,    in_channels=4		,    down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")		,    cross_attention_dim=32		,    conditioning_embedding_out_channels=(16, 32)		,    )
					controlneta.controlnet_down_blocks.apply(lowercase					)

					torch.manual_seed(0					)
					lowerCamelCase_         =     DDIMScheduler(
					    beta_start=0.0_0_0_8_5		,    beta_end=0.0_1_2		,    beta_schedule="scaled_linear"		,    clip_sample=lowercase		,    set_alpha_to_one=lowercase		,    )
					torch.manual_seed(0					)
					lowerCamelCase_         =     AutoencoderKL(
					    block_out_channels=[32, 64]		,    in_channels=3		,    out_channels=3		,    down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]		,    up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]		,    latent_channels=4		,    )
					torch.manual_seed(0					)
					lowerCamelCase_         =     CLIPTextConfig(
					    bos_token_id=0		,    eos_token_id=2		,    hidden_size=32		,    intermediate_size=37		,    layer_norm_eps=1e-05		,    num_attention_heads=4		,    num_hidden_layers=5		,    pad_token_id=1		,    vocab_size=1000		,    )
					lowerCamelCase_         =     CLIPTextModel(lowercase					)
					lowerCamelCase_         =     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"					)

					lowerCamelCase_         =     MultiControlNetModel([controlneta, controlneta]					)

					lowerCamelCase_         =     {
					    "unet": unet,
					    "controlnet": controlnet,
					    "scheduler": scheduler,
					    "vae": vae,
					    "text_encoder": text_encoder,
					    "tokenizer": tokenizer,
					    "safety_checker": None,
					    "feature_extractor": None,
					}
					return components



	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase=0					)							->			List[Any]:
					if str(lowercase					).startswith("mps"					):
									lowerCamelCase_         =     torch.manual_seed(lowercase					)
					else:
									lowerCamelCase_         =     torch.Generator(device=lowercase					).manual_seed(lowercase					)

					lowerCamelCase_         =     2

					lowerCamelCase_         =     [
					    randn_tensor(
					        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)		,    generator=lowercase		,    device=torch.device(lowercase					)		,    ),
					    randn_tensor(
					        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)		,    generator=lowercase		,    device=torch.device(lowercase					)		,    ),
					]

					lowerCamelCase_         =     floats_tensor(control_image[0].shape		,    rng=random.Random(lowercase					)					).to(lowercase					)
					lowerCamelCase_         =     image.cpu().permute(0		,    2		,    3		,    1					)[0]
					lowerCamelCase_         =     Image.fromarray(np.uinta(lowercase					)					).convert("RGB"					).resize((64, 64)					)
					lowerCamelCase_         =     {
					    "prompt": "A painting of a squirrel eating a burger",
					    "generator": generator,
					    "num_inference_steps": 2,
					    "guidance_scale": 6.0,
					    "output_type": "numpy",
					    "image": image,
					    "control_image": control_image,
					}

					return inputs



	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[Any]:
					lowerCamelCase_         =     self.get_dummy_components()
					lowerCamelCase_         =     self.pipeline_class(**lowercase					)
					pipe.to(lowercase					)

					lowerCamelCase_         =     1_0.0
					lowerCamelCase_         =     4

					lowerCamelCase_         =     self.get_dummy_inputs(lowercase					)
					lowerCamelCase_         =     steps
					lowerCamelCase_         =     scale
					lowerCamelCase_         =     pipe(**lowercase					)[0]

					lowerCamelCase_         =     self.get_dummy_inputs(lowercase					)
					lowerCamelCase_         =     steps
					lowerCamelCase_         =     scale
					lowerCamelCase_         =     pipe(**lowercase		,    control_guidance_start=0.1		,    control_guidance_end=0.2					)[0]

					lowerCamelCase_         =     self.get_dummy_inputs(lowercase					)
					lowerCamelCase_         =     steps
					lowerCamelCase_         =     scale
					lowerCamelCase_         =     pipe(**lowercase		,    control_guidance_start=[0.1, 0.3]		,    control_guidance_end=[0.2, 0.7]					)[0]

					lowerCamelCase_         =     self.get_dummy_inputs(lowercase					)
					lowerCamelCase_         =     steps
					lowerCamelCase_         =     scale
					lowerCamelCase_         =     pipe(**lowercase		,    control_guidance_start=0.4		,    control_guidance_end=[0.5, 0.8]					)[0]

					# make sure that all outputs are different
					assert np.sum(np.abs(output_a - output_a					)					) > 1e-3
					assert np.sum(np.abs(output_a - output_a					)					) > 1e-3
					assert np.sum(np.abs(output_a - output_a					)					) > 1e-3



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Dict:
					return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3					)



	@unittest.skipIf(
	    torch_device != "cuda" or not is_xformers_available()		,    reason="XFormers attention is only available with CUDA and `xformers` installed"		,    )
	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[int]:
					self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Union[str, Any]:
					self._test_inference_batch_single_identical(expected_max_diff=2e-3					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			int:
					lowerCamelCase_         =     self.get_dummy_components()
					lowerCamelCase_         =     self.pipeline_class(**lowercase					)
					pipe.to(lowercase					)
					pipe.set_progress_bar_config(disable=lowercase					)
					with tempfile.TemporaryDirectory() as tmpdir:
									try:
													# save_pretrained is not implemented for Multi-ControlNet
													pipe.save_pretrained(lowercase					)
									except NotImplementedError:
													pass




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



	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[Any]:
					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[int]:
					lowerCamelCase_         =     ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny"					)

					lowerCamelCase_         =     StableDiffusionControlNetImgaImgPipeline.from_pretrained(
					    "runwayml/stable-diffusion-v1-5"		,    safety_checker=lowercase		,    controlnet=lowercase					)
					pipe.enable_model_cpu_offload()
					pipe.set_progress_bar_config(disable=lowercase					)

					lowerCamelCase_         =     torch.Generator(device="cpu"					).manual_seed(0					)
					lowerCamelCase_         =     "evil space-punk bird"
					lowerCamelCase_         =     load_image(
					    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png"					).resize((512, 512)					)
					lowerCamelCase_         =     load_image(
					    "https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png"					).resize((512, 512)					)

					lowerCamelCase_         =     pipe(
					    lowercase		,    lowercase		,    control_image=lowercase		,    generator=lowercase		,    output_type="np"		,    num_inference_steps=50		,    strength=0.6		,    )

					lowerCamelCase_         =     output.images[0]

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

					lowerCamelCase_         =     load_numpy(
					    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/img2img.npy"					)

					assert np.abs(expected_image - image					).max() < 9e-2


