



import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModel,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableUnCLIPImgaImgPipeline, UNetaDConditionModel
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    floats_tensor,
    load_image,
    load_numpy,
    require_torch_gpu,
    skip_mps,
    slow,
    torch_device,
)

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


enable_full_determinism()



class 	lowerCamelCase      (						lowercase__,     lowercase__,     lowercase__,     unittest.TestCase  ):







					'''simple docstring'''







					lowerCAmelCase_				:    Dict									=  StableUnCLIPImgaImgPipeline
					lowerCAmelCase_				:    List[Any]									=  TEXT_GUIDED_IMAGE_VARIATION_PARAMS
					lowerCAmelCase_				:    int									=  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
					lowerCAmelCase_				:    Any									=  frozenset(
					    []  )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
					lowerCAmelCase_				:    Optional[int]									=  frozenset([]  )



					def    A__		(			self     ):
							UpperCAmelCase_						=				32
							UpperCAmelCase_						=				embedder_hidden_size

							# image encoding components

							UpperCAmelCase_						=				CLIPImageProcessor(crop_size=32    ,	size=32     )

							torch.manual_seed(0     )
							UpperCAmelCase_						=				CLIPVisionModelWithProjection(
							    CLIPVisionConfig(
							        hidden_size=lowerCAmelCase    ,	projection_dim=lowerCAmelCase    ,	num_hidden_layers=5    ,	num_attention_heads=4    ,	image_size=32    ,	intermediate_size=37    ,	patch_size=1    ,	)     )

							# regular denoising components

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

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

							torch.manual_seed(0     )
							UpperCAmelCase_						=				CLIPTextModel(
							    CLIPTextConfig(
							        bos_token_id=0    ,	eos_token_id=2    ,	hidden_size=lowerCAmelCase    ,	projection_dim=32    ,	intermediate_size=37    ,	layer_norm_eps=1e-0_5    ,	num_attention_heads=4    ,	num_hidden_layers=5    ,	pad_token_id=1    ,	vocab_size=1000    ,	)     )

							torch.manual_seed(0     )
							UpperCAmelCase_						=				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=lowerCAmelCase    ,	layers_per_block=1    ,	upcast_attention=lowerCAmelCase    ,	use_linear_projection=lowerCAmelCase    ,	)

							torch.manual_seed(0     )
							UpperCAmelCase_						=				DDIMScheduler(
							    beta_schedule="scaled_linear"    ,	beta_start=0.00085    ,	beta_end=0.012    ,	prediction_type="v_prediction"    ,	set_alpha_to_one=lowerCAmelCase    ,	steps_offset=1    ,	)

							torch.manual_seed(0     )
							UpperCAmelCase_						=				AutoencoderKL()

							UpperCAmelCase_						=				{
							    # image encoding components
							    "feature_extractor": feature_extractor,
							    "image_encoder": image_encoder.eval(),
							    # image noising components
							    "image_normalizer": image_normalizer.eval(),
							    "image_noising_scheduler": image_noising_scheduler,
							    # regular denoising components
							    "tokenizer": tokenizer,
							    "text_encoder": text_encoder.eval(),
							    "unet": unet.eval(),
							    "scheduler": scheduler,
							    "vae": vae.eval(),
							}

							return components



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

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

							if pil_image:
									UpperCAmelCase_						=				input_image * 0.5 + 0.5
									UpperCAmelCase_						=				input_image.clamp(0    ,	1     )
									UpperCAmelCase_						=				input_image.cpu().permute(0    ,	2    ,	3    ,	1     ).float().numpy()
									UpperCAmelCase_						=				DiffusionPipeline.numpy_to_pil(lowerCAmelCase     )[0]

							return {
							    "prompt": "An anime racoon running a marathon",
							    "image": input_image,
							    "generator": generator,
							    "num_inference_steps": 2,
							    "output_type": "np",
							}



					@skip_mps
					def    A__		(			self     ):
							UpperCAmelCase_						=				"cpu"  # ensure determinism for the device-dependent torch.Generator
							UpperCAmelCase_						=				self.get_dummy_components()
							UpperCAmelCase_						=				StableUnCLIPImgaImgPipeline(**lowerCAmelCase     )
							UpperCAmelCase_						=				sd_pipe.to(lowerCAmelCase     )
							sd_pipe.set_progress_bar_config(disable=lowerCAmelCase     )

							UpperCAmelCase_						=				self.get_dummy_inputs(lowerCAmelCase     )
							inputs.update({"image_embeds": None}     )
							UpperCAmelCase_						=				sd_pipe(**lowerCAmelCase     ).images
							UpperCAmelCase_						=				image[0, -3:, -3:, -1]

							assert image.shape == (1, 32, 32, 3)
							UpperCAmelCase_						=				np.array([0.3872, 0.7224, 0.5601, 0.4741, 0.6872, 0.5814, 0.4636, 0.3867, 0.5078]     )

							assert np.abs(image_slice.flatten() - expected_slice     ).max() < 1e-3



					def    A__		(			self     ):
							UpperCAmelCase_						=				torch_device in ["cpu", "mps"]

							self._test_attention_slicing_forward_pass(test_max_difference=lowerCAmelCase     )



					def    A__		(			self     ):
							UpperCAmelCase_						=				torch_device in ["cpu", "mps"]

							self._test_inference_batch_single_identical(test_max_difference=lowerCAmelCase     )



					@unittest.skipIf(
					    torch_device != "cuda" or not is_xformers_available()    ,	reason="XFormers attention is only available with CUDA and `xformers` installed"    ,	)
					def    A__		(			self     ):
							self._test_xformers_attention_forwardGenerator_pass(test_max_difference=lowerCAmelCase     )





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







					'''simple docstring'''







					def    A__		(			self     ):
							# clean up the VRAM after each test
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()



					def    A__		(			self     ):
							UpperCAmelCase_						=				load_image(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"     )

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

							UpperCAmelCase_						=				StableUnCLIPImgaImgPipeline.from_pretrained(
							    "fusing/stable-unclip-2-1-l-img2img"    ,	torch_dtype=torch.floataa     )
							pipe.to(lowerCAmelCase     )
							pipe.set_progress_bar_config(disable=lowerCAmelCase     )
							# 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()

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

							UpperCAmelCase_						=				output.images[0]

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

							assert_mean_pixel_difference(lowerCAmelCase    ,	lowerCAmelCase     )



					def    A__		(			self     ):
							UpperCAmelCase_						=				load_image(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"     )

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

							UpperCAmelCase_						=				StableUnCLIPImgaImgPipeline.from_pretrained(
							    "fusing/stable-unclip-2-1-h-img2img"    ,	torch_dtype=torch.floataa     )
							pipe.to(lowerCAmelCase     )
							pipe.set_progress_bar_config(disable=lowerCAmelCase     )
							# 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()

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

							UpperCAmelCase_						=				output.images[0]

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

							assert_mean_pixel_difference(lowerCAmelCase    ,	lowerCAmelCase     )



					def    A__		(			self     ):
							UpperCAmelCase_						=				load_image(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"     )

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

							UpperCAmelCase_						=				StableUnCLIPImgaImgPipeline.from_pretrained(
							    "fusing/stable-unclip-2-1-h-img2img"    ,	torch_dtype=torch.floataa     )
							UpperCAmelCase_						=				pipe.to(lowerCAmelCase     )
							pipe.set_progress_bar_config(disable=lowerCAmelCase     )
							pipe.enable_attention_slicing()
							pipe.enable_sequential_cpu_offload()

							UpperCAmelCase_						=				pipe(
							    lowerCAmelCase    ,	"anime turtle"    ,	num_inference_steps=2    ,	output_type="np"    ,	)

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










import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_distilbert import DistilBertTokenizer


SCREAMING_SNAKE_CASE     				=						logging.get_logger(__name__)

SCREAMING_SNAKE_CASE     				=						{"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}

SCREAMING_SNAKE_CASE     				=						{
    "vocab_file": {
        "distilbert-base-uncased": "https://huggingface.co/distilbert-base-uncased/resolve/main/vocab.txt",
        "distilbert-base-uncased-distilled-squad": (
            "https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/vocab.txt"
        ),
        "distilbert-base-cased": "https://huggingface.co/distilbert-base-cased/resolve/main/vocab.txt",
        "distilbert-base-cased-distilled-squad": (
            "https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/vocab.txt"
        ),
        "distilbert-base-german-cased": "https://huggingface.co/distilbert-base-german-cased/resolve/main/vocab.txt",
        "distilbert-base-multilingual-cased": (
            "https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "distilbert-base-uncased": "https://huggingface.co/distilbert-base-uncased/resolve/main/tokenizer.json",
        "distilbert-base-uncased-distilled-squad": (
            "https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/tokenizer.json"
        ),
        "distilbert-base-cased": "https://huggingface.co/distilbert-base-cased/resolve/main/tokenizer.json",
        "distilbert-base-cased-distilled-squad": (
            "https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/tokenizer.json"
        ),
        "distilbert-base-german-cased": (
            "https://huggingface.co/distilbert-base-german-cased/resolve/main/tokenizer.json"
        ),
        "distilbert-base-multilingual-cased": (
            "https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/tokenizer.json"
        ),
    },
}

SCREAMING_SNAKE_CASE     				=						{
    "distilbert-base-uncased": 512,
    "distilbert-base-uncased-distilled-squad": 512,
    "distilbert-base-cased": 512,
    "distilbert-base-cased-distilled-squad": 512,
    "distilbert-base-german-cased": 512,
    "distilbert-base-multilingual-cased": 512,
}


SCREAMING_SNAKE_CASE     				=						{
    "distilbert-base-uncased": {"do_lower_case": True},
    "distilbert-base-uncased-distilled-squad": {"do_lower_case": True},
    "distilbert-base-cased": {"do_lower_case": False},
    "distilbert-base-cased-distilled-squad": {"do_lower_case": False},
    "distilbert-base-german-cased": {"do_lower_case": False},
    "distilbert-base-multilingual-cased": {"do_lower_case": False},
}



class 	lowerCamelCase      (						lowercase__  ):







					'''simple docstring'''







					lowerCAmelCase_				:    Any									=  VOCAB_FILES_NAMES
					lowerCAmelCase_				:    List[str]									=  PRETRAINED_VOCAB_FILES_MAP
					lowerCAmelCase_				:    str									=  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					lowerCAmelCase_				:    Union[str, Any]									=  PRETRAINED_INIT_CONFIGURATION
					lowerCAmelCase_				:    int									=  ['input_ids', 'attention_mask']
					lowerCAmelCase_				:    str									=  DistilBertTokenizer



					def __init__(			self    ,	lowerCAmelCase=None    ,	lowerCAmelCase=None    ,	lowerCAmelCase=True    ,	lowerCAmelCase="[UNK]"    ,	lowerCAmelCase="[SEP]"    ,	lowerCAmelCase="[PAD]"    ,	lowerCAmelCase="[CLS]"    ,	lowerCAmelCase="[MASK]"    ,	lowerCAmelCase=True    ,	lowerCAmelCase=None    ,	**lowerCAmelCase    ,	):
							super().__init__(
							    lowerCAmelCase    ,	tokenizer_file=lowerCAmelCase    ,	do_lower_case=lowerCAmelCase    ,	unk_token=lowerCAmelCase    ,	sep_token=lowerCAmelCase    ,	pad_token=lowerCAmelCase    ,	cls_token=lowerCAmelCase    ,	mask_token=lowerCAmelCase    ,	tokenize_chinese_chars=lowerCAmelCase    ,	strip_accents=lowerCAmelCase    ,	**lowerCAmelCase    ,	)

							UpperCAmelCase_						=				json.loads(self.backend_tokenizer.normalizer.__getstate__()     )
							if (
							    normalizer_state.get("lowercase"    ,	lowerCAmelCase     ) != do_lower_case
							    or normalizer_state.get("strip_accents"    ,	lowerCAmelCase     ) != strip_accents
							    or normalizer_state.get("handle_chinese_chars"    ,	lowerCAmelCase     ) != tokenize_chinese_chars
							):
									UpperCAmelCase_						=				getattr(lowerCAmelCase    ,	normalizer_state.pop("type"     )     )
									UpperCAmelCase_						=				do_lower_case
									UpperCAmelCase_						=				strip_accents
									UpperCAmelCase_						=				tokenize_chinese_chars
									UpperCAmelCase_						=				normalizer_class(**lowerCAmelCase     )

							UpperCAmelCase_						=				do_lower_case



					def    A__		(			self    ,	lowerCAmelCase    ,	lowerCAmelCase=None     ):
							UpperCAmelCase_						=				[self.cls_token_id] + token_ids_a + [self.sep_token_id]

							if token_ids_a:
									output += token_ids_a + [self.sep_token_id]

							return output



					def    A__		(			self    ,	lowerCAmelCase    ,	lowerCAmelCase = None     ):
							UpperCAmelCase_						=				[self.sep_token_id]
							UpperCAmelCase_						=				[self.cls_token_id]
							if token_ids_a is None:
									return len(cls + token_ids_a + sep     ) * [0]
							return len(cls + token_ids_a + sep     ) * [0] + len(token_ids_a + sep     ) * [1]



					def    A__		(			self    ,	lowerCAmelCase    ,	lowerCAmelCase = None     ):
							UpperCAmelCase_						=				self._tokenizer.model.save(lowerCAmelCase    ,	name=lowerCAmelCase     )
							return tuple(lowerCAmelCase     )

