
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 					lowerCamelCase		(  A_							,			A_							,			A_							,			unittest.TestCase  ):
					UpperCAmelCase__    :							Optional[int]									=		StableUnCLIPPipeline
					UpperCAmelCase__    :							Dict									=		TEXT_TO_IMAGE_PARAMS
					UpperCAmelCase__    :							Union[str, Any]									=		TEXT_TO_IMAGE_BATCH_PARAMS
					UpperCAmelCase__    :							Any									=		TEXT_TO_IMAGE_IMAGE_PARAMS
					UpperCAmelCase__    :							str									=		TEXT_TO_IMAGE_IMAGE_PARAMS

					# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
					UpperCAmelCase__    :							Union[str, Any]									=		False





					def 		UpperCAmelCase(self				:   Tuple       )						->						Union[str, Any]:
									snake_case								= 3_2
									snake_case								= embedder_hidden_size

									# prior components

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

									torch.manual_seed(0       )
									snake_case								= CLIPTextModelWithProjection(
									    CLIPTextConfig(
									        bos_token_id=0    ,   eos_token_id=2    ,   hidden_size=_A    ,   projection_dim=_A    ,   intermediate_size=3_7    ,   layer_norm_eps=1E-05    ,   num_attention_heads=4    ,   num_hidden_layers=5    ,   pad_token_id=1    ,   vocab_size=1_0_0_0    ,   )       )

									torch.manual_seed(0       )
									snake_case								= PriorTransformer(
									    num_attention_heads=2    ,   attention_head_dim=1_2    ,   embedding_dim=_A    ,   num_layers=1    ,   )

									torch.manual_seed(0       )
									snake_case								= DDPMScheduler(
									    variance_type="fixed_small_log"    ,   prediction_type="sample"    ,   num_train_timesteps=1_0_0_0    ,   clip_sample=_A    ,   clip_sample_range=5.0    ,   beta_schedule="squaredcos_cap_v2"    ,   )

									# regular denoising components

									torch.manual_seed(0       )
									snake_case								= StableUnCLIPImageNormalizer(embedding_dim=_A       )
									snake_case								= DDPMScheduler(beta_schedule="squaredcos_cap_v2"       )

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

									torch.manual_seed(0       )
									snake_case								= CLIPTextModel(
									    CLIPTextConfig(
									        bos_token_id=0    ,   eos_token_id=2    ,   hidden_size=_A    ,   projection_dim=3_2    ,   intermediate_size=3_7    ,   layer_norm_eps=1E-05    ,   num_attention_heads=4    ,   num_hidden_layers=5    ,   pad_token_id=1    ,   vocab_size=1_0_0_0    ,   )       )

									torch.manual_seed(0       )
									snake_case								= UNetaDConditionModel(
									    sample_size=3_2    ,   in_channels=4    ,   out_channels=4    ,   down_block_types=("CrossAttnDownBlock2D", "DownBlock2D")    ,   up_block_types=("UpBlock2D", "CrossAttnUpBlock2D")    ,   block_out_channels=(3_2, 6_4)    ,   attention_head_dim=(2, 4)    ,   class_embed_type="projection"    ,   projection_class_embeddings_input_dim=embedder_projection_dim * 2    ,   cross_attention_dim=_A    ,   layers_per_block=1    ,   upcast_attention=_A    ,   use_linear_projection=_A    ,   )

									torch.manual_seed(0       )
									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=_A    ,   steps_offset=1    ,   )

									torch.manual_seed(0       )
									snake_case								= AutoencoderKL()

									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				:   Union[str, Any]    ,   _A				:   List[Any]    ,   _A				:   str=0       )						->						List[Any]:
									if str(_A       ).startswith("mps"       ):
													snake_case								= torch.manual_seed(_A       )
									else:
													snake_case								= torch.Generator(device=_A       ).manual_seed(_A       )
									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				:   Tuple       )						->						str:
									snake_case								= torch_device == "cpu"

									self._test_attention_slicing_forward_pass(test_max_difference=_A       )





					def 		UpperCAmelCase(self				:   Any       )						->						Dict:
									snake_case								= torch_device in ["cpu", "mps"]

									self._test_inference_batch_single_identical(test_max_difference=_A       )







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





					def 		UpperCAmelCase(self				:   Union[str, Any]       )						->						Tuple:
									# clean up the VRAM after each test
									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()





					def 		UpperCAmelCase(self				:   str       )						->						Optional[Any]:
									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"       )

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

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

									snake_case								= output.images[0]

									assert image.shape == (7_6_8, 7_6_8, 3)

									assert_mean_pixel_difference(_A    ,   _A       )





					def 		UpperCAmelCase(self				:   Union[str, Any]       )						->						str:
									torch.cuda.empty_cache()
									torch.cuda.reset_max_memory_allocated()
									torch.cuda.reset_peak_memory_stats()

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

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

									snake_case								= torch.cuda.max_memory_allocated()
									# make sure that less than 7 GB is allocated
									assert mem_bytes < 7 * 1_0**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_bert import BertTokenizer


_A   =			logging.get_logger(__name__)

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

_A   =			{
    "vocab_file": {
        "bert-base-uncased": "https://huggingface.co/bert-base-uncased/resolve/main/vocab.txt",
        "bert-large-uncased": "https://huggingface.co/bert-large-uncased/resolve/main/vocab.txt",
        "bert-base-cased": "https://huggingface.co/bert-base-cased/resolve/main/vocab.txt",
        "bert-large-cased": "https://huggingface.co/bert-large-cased/resolve/main/vocab.txt",
        "bert-base-multilingual-uncased": (
            "https://huggingface.co/bert-base-multilingual-uncased/resolve/main/vocab.txt"
        ),
        "bert-base-multilingual-cased": "https://huggingface.co/bert-base-multilingual-cased/resolve/main/vocab.txt",
        "bert-base-chinese": "https://huggingface.co/bert-base-chinese/resolve/main/vocab.txt",
        "bert-base-german-cased": "https://huggingface.co/bert-base-german-cased/resolve/main/vocab.txt",
        "bert-large-uncased-whole-word-masking": (
            "https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/vocab.txt"
        ),
        "bert-large-cased-whole-word-masking": (
            "https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/vocab.txt"
        ),
        "bert-large-uncased-whole-word-masking-finetuned-squad": (
            "https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt"
        ),
        "bert-large-cased-whole-word-masking-finetuned-squad": (
            "https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt"
        ),
        "bert-base-cased-finetuned-mrpc": (
            "https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/vocab.txt"
        ),
        "bert-base-german-dbmdz-cased": "https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/vocab.txt",
        "bert-base-german-dbmdz-uncased": (
            "https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/vocab.txt"
        ),
        "TurkuNLP/bert-base-finnish-cased-v1": (
            "https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/vocab.txt"
        ),
        "TurkuNLP/bert-base-finnish-uncased-v1": (
            "https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/vocab.txt"
        ),
        "wietsedv/bert-base-dutch-cased": (
            "https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "bert-base-uncased": "https://huggingface.co/bert-base-uncased/resolve/main/tokenizer.json",
        "bert-large-uncased": "https://huggingface.co/bert-large-uncased/resolve/main/tokenizer.json",
        "bert-base-cased": "https://huggingface.co/bert-base-cased/resolve/main/tokenizer.json",
        "bert-large-cased": "https://huggingface.co/bert-large-cased/resolve/main/tokenizer.json",
        "bert-base-multilingual-uncased": (
            "https://huggingface.co/bert-base-multilingual-uncased/resolve/main/tokenizer.json"
        ),
        "bert-base-multilingual-cased": (
            "https://huggingface.co/bert-base-multilingual-cased/resolve/main/tokenizer.json"
        ),
        "bert-base-chinese": "https://huggingface.co/bert-base-chinese/resolve/main/tokenizer.json",
        "bert-base-german-cased": "https://huggingface.co/bert-base-german-cased/resolve/main/tokenizer.json",
        "bert-large-uncased-whole-word-masking": (
            "https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/tokenizer.json"
        ),
        "bert-large-cased-whole-word-masking": (
            "https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/tokenizer.json"
        ),
        "bert-large-uncased-whole-word-masking-finetuned-squad": (
            "https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json"
        ),
        "bert-large-cased-whole-word-masking-finetuned-squad": (
            "https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json"
        ),
        "bert-base-cased-finetuned-mrpc": (
            "https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/tokenizer.json"
        ),
        "bert-base-german-dbmdz-cased": (
            "https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/tokenizer.json"
        ),
        "bert-base-german-dbmdz-uncased": (
            "https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/tokenizer.json"
        ),
        "TurkuNLP/bert-base-finnish-cased-v1": (
            "https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/tokenizer.json"
        ),
        "TurkuNLP/bert-base-finnish-uncased-v1": (
            "https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/tokenizer.json"
        ),
        "wietsedv/bert-base-dutch-cased": (
            "https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/tokenizer.json"
        ),
    },
}

_A   =			{
    "bert-base-uncased": 5_12,
    "bert-large-uncased": 5_12,
    "bert-base-cased": 5_12,
    "bert-large-cased": 5_12,
    "bert-base-multilingual-uncased": 5_12,
    "bert-base-multilingual-cased": 5_12,
    "bert-base-chinese": 5_12,
    "bert-base-german-cased": 5_12,
    "bert-large-uncased-whole-word-masking": 5_12,
    "bert-large-cased-whole-word-masking": 5_12,
    "bert-large-uncased-whole-word-masking-finetuned-squad": 5_12,
    "bert-large-cased-whole-word-masking-finetuned-squad": 5_12,
    "bert-base-cased-finetuned-mrpc": 5_12,
    "bert-base-german-dbmdz-cased": 5_12,
    "bert-base-german-dbmdz-uncased": 5_12,
    "TurkuNLP/bert-base-finnish-cased-v1": 5_12,
    "TurkuNLP/bert-base-finnish-uncased-v1": 5_12,
    "wietsedv/bert-base-dutch-cased": 5_12,
}

_A   =			{
    "bert-base-uncased": {"do_lower_case": True},
    "bert-large-uncased": {"do_lower_case": True},
    "bert-base-cased": {"do_lower_case": False},
    "bert-large-cased": {"do_lower_case": False},
    "bert-base-multilingual-uncased": {"do_lower_case": True},
    "bert-base-multilingual-cased": {"do_lower_case": False},
    "bert-base-chinese": {"do_lower_case": False},
    "bert-base-german-cased": {"do_lower_case": False},
    "bert-large-uncased-whole-word-masking": {"do_lower_case": True},
    "bert-large-cased-whole-word-masking": {"do_lower_case": False},
    "bert-large-uncased-whole-word-masking-finetuned-squad": {"do_lower_case": True},
    "bert-large-cased-whole-word-masking-finetuned-squad": {"do_lower_case": False},
    "bert-base-cased-finetuned-mrpc": {"do_lower_case": False},
    "bert-base-german-dbmdz-cased": {"do_lower_case": False},
    "bert-base-german-dbmdz-uncased": {"do_lower_case": True},
    "TurkuNLP/bert-base-finnish-cased-v1": {"do_lower_case": False},
    "TurkuNLP/bert-base-finnish-uncased-v1": {"do_lower_case": True},
    "wietsedv/bert-base-dutch-cased": {"do_lower_case": False},
}







class 					lowerCamelCase		(  A_  ):
     UpperCAmelCase__    :							Optional[Any]									=		VOCAB_FILES_NAMES
     UpperCAmelCase__    :							Union[str, Any]									=		PRETRAINED_VOCAB_FILES_MAP
     UpperCAmelCase__    :							Union[str, Any]									=		PRETRAINED_INIT_CONFIGURATION
     UpperCAmelCase__    :							Any									=		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     UpperCAmelCase__    :							int									=		BertTokenizer





     def __init__(self				:   Union[str, Any]    ,   _A				:   Union[str, Any]=None    ,   _A				:   Optional[int]=None    ,   _A				:   List[str]=True    ,   _A				:   List[Any]="[UNK]"    ,   _A				:   Union[str, Any]="[SEP]"    ,   _A				:   List[Any]="[PAD]"    ,   _A				:   List[Any]="[CLS]"    ,   _A				:   Union[str, Any]="[MASK]"    ,   _A				:   int=True    ,   _A				:   Tuple=None    ,   **_A				:   Optional[int]    ,   )						->						int:
         super().__init__(
             _A    ,   tokenizer_file=_A    ,   do_lower_case=_A    ,   unk_token=_A    ,   sep_token=_A    ,   pad_token=_A    ,   cls_token=_A    ,   mask_token=_A    ,   tokenize_chinese_chars=_A    ,   strip_accents=_A    ,   **_A    ,   )

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

         snake_case								= do_lower_case





     def 		UpperCAmelCase(self				:   str    ,   _A				:   Union[str, Any]    ,   _A				:   int=None       )						->						Any:
         snake_case								= [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 		UpperCAmelCase(self				:   Optional[Any]    ,   _A				:   List[int]    ,   _A				:   Optional[List[int]] = None       )						->						List[int]:
         snake_case								= [self.sep_token_id]
         snake_case								= [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 		UpperCAmelCase(self				:   Union[str, Any]    ,   _A				:   str    ,   _A				:   Optional[str] = None       )						->						Tuple[str]:
         snake_case								= self._tokenizer.model.save(_A    ,   name=_A       )
         return tuple(_A       )

