




'''simple docstring'''





import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import require_torch_gpu

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


_lowerCAmelCase						:   List[Any]		=   False
@skip_mps
class 			_UpperCamelCase      (				lowerCAmelCase	,       lowerCAmelCase	,       lowerCAmelCase	,       unittest.TestCase		):
      UpperCAmelCase_        =		StableDiffusionAttendAndExcitePipeline
      UpperCAmelCase_        =		False
      UpperCAmelCase_        =		TEXT_TO_IMAGE_PARAMS
      UpperCAmelCase_        =		TEXT_TO_IMAGE_BATCH_PARAMS.union({"""token_indices"""}		)
      UpperCAmelCase_        =		TEXT_TO_IMAGE_IMAGE_PARAMS
      UpperCAmelCase_        =		TEXT_TO_IMAGE_IMAGE_PARAMS
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[Any]      )     ->			Optional[Any]:
       super().setUpClass()
       torch.use_deterministic_algorithms(lowerCamelCase      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Tuple      )     ->			str:
       super().tearDownClass()
       torch.use_deterministic_algorithms(lowerCamelCase      )
      def 	UpperCAmelCase_						(			self   :Any      )     ->			Any:
       torch.manual_seed(0      )
       UpperCAmelCase__							 =						UNetaDConditionModel(
           block_out_channels=(32, 64) ,      layers_per_block=1 ,      sample_size=32 ,      in_channels=4 ,      out_channels=4 ,      down_block_types=("DownBlock2D", "CrossAttnDownBlock2D") ,      up_block_types=("CrossAttnUpBlock2D", "UpBlock2D") ,      cross_attention_dim=32 ,      attention_head_dim=(2, 4) ,      use_linear_projection=lowerCamelCase ,      )
       UpperCAmelCase__							 =						DDIMScheduler(
           beta_start=0.0_00_85 ,      beta_end=0.0_12 ,      beta_schedule="scaled_linear" ,      clip_sample=lowerCamelCase ,      set_alpha_to_one=lowerCamelCase ,      )
       torch.manual_seed(0      )
       UpperCAmelCase__							 =						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 ,      sample_size=128 ,      )
       torch.manual_seed(0      )
       UpperCAmelCase__							 =						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 ,      hidden_act="gelu" ,      projection_dim=512 ,      )
       UpperCAmelCase__							 =						CLIPTextModel(lowerCamelCase      )
       UpperCAmelCase__							 =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"      )

       UpperCAmelCase__							 =						{
           "unet": unet,
           "scheduler": scheduler,
           "vae": vae,
           "text_encoder": text_encoder,
           "tokenizer": tokenizer,
           "safety_checker": None,
           "feature_extractor": None,
       }

       return components
      def 	UpperCAmelCase_						(			self   :Union[str, Any] ,      lowerCamelCase   :Union[str, Any] ,      lowerCamelCase   :Optional[Any]=0      )     ->			Union[str, Any]:
       if str(lowerCamelCase      ).startswith("mps"      ):
        UpperCAmelCase__							 =						torch.manual_seed(lowerCamelCase      )
       else:
        UpperCAmelCase__							 =						torch.Generator(device=lowerCamelCase      ).manual_seed(lowerCamelCase      )
       UpperCAmelCase__							 =						UpperCAmelCase__							 =						{
           "prompt": "a cat and a frog",
           "token_indices": [2, 5],
           "generator": generator,
           "num_inference_steps": 1,
           "guidance_scale": 6.0,
           "output_type": "numpy",
           "max_iter_to_alter": 2,
           "thresholds": {0: 0.7},
       }
       return inputs
      def 	UpperCAmelCase_						(			self   :Union[str, Any]      )     ->			str:
       UpperCAmelCase__							 =						"cpu"

       UpperCAmelCase__							 =						self.get_dummy_components()
       UpperCAmelCase__							 =						self.pipeline_class(**lowerCamelCase      )
       pipe.to(lowerCamelCase      )
       pipe.set_progress_bar_config(disable=lowerCamelCase      )

       UpperCAmelCase__							 =						self.get_dummy_inputs(lowerCamelCase      )
       UpperCAmelCase__							 =						pipe(**lowerCamelCase      ).images
       UpperCAmelCase__							 =						image[0, -3:, -3:, -1]

       self.assertEqual(image.shape ,      (1, 64, 64, 3)      )
       UpperCAmelCase__							 =						np.array(
           [0.63_90_53_64, 0.62_89_73_07, 0.48_59_90_17, 0.5_13_36_24, 0.5_55_00_48, 0.45_76_95_16, 0.50_32_69_73, 0.5_02_31_39, 0.45_38_44_96]      )
       UpperCAmelCase__							 =						np.abs(image_slice.flatten() - expected_slice      ).max()
       self.assertLessEqual(lowerCamelCase ,      1e-3      )
      def 	UpperCAmelCase_						(			self   :int      )     ->			Optional[int]:
       super().test_cpu_offload_forward_pass(expected_max_diff=5e-4      )
      def 	UpperCAmelCase_						(			self   :str      )     ->			Union[str, Any]:
       # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
       self._test_inference_batch_consistent(batch_sizes=[1, 2]      )
      def 	UpperCAmelCase_						(			self   :List[str]      )     ->			Tuple:
       self._test_inference_batch_single_identical(batch_size=2 ,      expected_max_diff=7e-4      )
      def 	UpperCAmelCase_						(			self   :List[str]      )     ->			Union[str, Any]:
       super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3      )
      def 	UpperCAmelCase_						(			self   :List[str]      )     ->			Tuple:
       super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4      )
      def 	UpperCAmelCase_						(			self   :Dict      )     ->			Union[str, Any]:
       super().test_save_load_local(expected_max_difference=5e-4      )







      def 	UpperCAmelCase_						(			self   :Optional[int]      )     ->			Dict:
       super().test_save_load_optional_components(expected_max_difference=4e-4      )



@require_torch_gpu
@slow
class 			_UpperCamelCase      (				unittest.TestCase		):
      @classmethod
      def 	UpperCAmelCase_						(			cls   :str      )     ->			List[str]:
       super().setUpClass()
       torch.use_deterministic_algorithms(lowerCamelCase      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[Any]      )     ->			Tuple:
       super().tearDownClass()
       torch.use_deterministic_algorithms(lowerCamelCase      )
      def 	UpperCAmelCase_						(			self   :str      )     ->			List[Any]:
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()







      def 	UpperCAmelCase_						(			self   :List[str]      )     ->			str:
       UpperCAmelCase__							 =						torch.manual_seed(51      )

       UpperCAmelCase__							 =						StableDiffusionAttendAndExcitePipeline.from_pretrained(
           "CompVis/stable-diffusion-v1-4" ,      safety_checker=lowerCamelCase ,      torch_dtype=torch.floataa      )
       pipe.to("cuda"      )

       UpperCAmelCase__							 =						"a painting of an elephant with glasses"
       UpperCAmelCase__							 =						[5, 7]

       UpperCAmelCase__							 =						pipe(
           prompt=lowerCamelCase ,      token_indices=lowerCamelCase ,      guidance_scale=7.5 ,      generator=lowerCamelCase ,      num_inference_steps=5 ,      max_iter_to_alter=5 ,      output_type="numpy" ,      ).images[0]

       UpperCAmelCase__							 =						load_numpy(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy"      )
       assert np.abs((expected_image - image).max()      ) < 5e-1











import json
from typing import TYPE_CHECKING, List, Optional, Tuple

from tokenizers import pre_tokenizers

from ...tokenization_utils_base import BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging


if TYPE_CHECKING:
  from transformers.pipelines.conversational import Conversation


_lowerCAmelCase						:   str		=   logging.get_logger(__name__)

_lowerCAmelCase						:   List[Any]		=   {"tokenizer_file": "tokenizer.json"}

_lowerCAmelCase						:   Tuple		=   {
    "tokenizer_file": {
        "bigscience/tokenizer": "https://huggingface.co/bigscience/tokenizer/blob/main/tokenizer.json",
        "bigscience/bloom-560m": "https://huggingface.co/bigscience/bloom-560m/blob/main/tokenizer.json",
        "bigscience/bloom-1b1": "https://huggingface.co/bigscience/bloom-1b1/blob/main/tokenizer.json",
        "bigscience/bloom-1b7": "https://huggingface.co/bigscience/bloom-1b7/blob/main/tokenizer.json",
        "bigscience/bloom-3b": "https://huggingface.co/bigscience/bloom-3b/blob/main/tokenizer.json",
        "bigscience/bloom-7b1": "https://huggingface.co/bigscience/bloom-7b1/blob/main/tokenizer.json",
        "bigscience/bloom": "https://huggingface.co/bigscience/bloom/blob/main/tokenizer.json",
    },
}
class 			_UpperCamelCase      (				lowerCAmelCase		):
      UpperCAmelCase_        =		VOCAB_FILES_NAMES
      UpperCAmelCase_        =		PRETRAINED_VOCAB_FILES_MAP
      UpperCAmelCase_        =		["""input_ids""", """attention_mask"""]
      UpperCAmelCase_        =		None
      def __init__(			self   :List[Any] ,      lowerCamelCase   :Union[str, Any]=None ,      lowerCamelCase   :Optional[Any]=None ,      lowerCamelCase   :List[Any]=None ,      lowerCamelCase   :Union[str, Any]="<unk>" ,      lowerCamelCase   :Union[str, Any]="<s>" ,      lowerCamelCase   :Union[str, Any]="</s>" ,      lowerCamelCase   :str="<pad>" ,      lowerCamelCase   :Any=False ,      lowerCamelCase   :Optional[Any]=False ,      **lowerCamelCase   :Optional[Any] ,      )     ->			Any:
       super().__init__(
           lowerCamelCase ,      lowerCamelCase ,      tokenizer_file=lowerCamelCase ,      unk_token=lowerCamelCase ,      bos_token=lowerCamelCase ,      eos_token=lowerCamelCase ,      pad_token=lowerCamelCase ,      add_prefix_space=lowerCamelCase ,      clean_up_tokenization_spaces=lowerCamelCase ,      **lowerCamelCase ,      )
       UpperCAmelCase__							 =						json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()      )
       if pre_tok_state.get("add_prefix_space" ,      lowerCamelCase      ) != add_prefix_space:
        UpperCAmelCase__							 =						getattr(lowerCamelCase ,      pre_tok_state.pop("type"      )      )
        UpperCAmelCase__							 =						add_prefix_space
        UpperCAmelCase__							 =						pre_tok_class(**lowerCamelCase      )

       UpperCAmelCase__							 =						add_prefix_space
      def 	UpperCAmelCase_						(			self   :int ,      *lowerCamelCase   :Any ,      **lowerCamelCase   :int      )     ->			BatchEncoding:
       UpperCAmelCase__							 =						kwargs.get("is_split_into_words" ,      lowerCamelCase      )
       if not (self.add_prefix_space or not is_split_into_words):
        raise Exception(
            f'''You need to instantiate {self.__class__.__name__} with add_prefix_space=True to use it with'''
            " pretokenized inputs."      )

       return super()._batch_encode_plus(*lowerCamelCase ,      **lowerCamelCase      )
      def 	UpperCAmelCase_						(			self   :Any ,      *lowerCamelCase   :List[Any] ,      **lowerCamelCase   :Union[str, Any]      )     ->			BatchEncoding:
       UpperCAmelCase__							 =						kwargs.get("is_split_into_words" ,      lowerCamelCase      )

       if not (self.add_prefix_space or not is_split_into_words):
        raise Exception(
            f'''You need to instantiate {self.__class__.__name__} with add_prefix_space=True to use it with'''
            " pretokenized inputs."      )

       return super()._encode_plus(*lowerCamelCase ,      **lowerCamelCase      )
      def 	UpperCAmelCase_						(			self   :Tuple ,      lowerCamelCase   :str ,      lowerCamelCase   :Optional[str] = None      )     ->			Tuple[str]:
       UpperCAmelCase__							 =						self._tokenizer.model.save(lowerCamelCase ,      name=lowerCamelCase      )
       return tuple(lowerCamelCase      )







      def 	UpperCAmelCase_						(			self   :List[str] ,      lowerCamelCase   :"Conversation"      )     ->			List[int]:
       UpperCAmelCase__							 =						[]
       for is_user, text in conversation.iter_texts():
        input_ids.extend(self.encode(lowerCamelCase ,      add_special_tokens=lowerCamelCase      ) + [self.eos_token_id]      )

       if len(lowerCamelCase      ) > self.model_max_length:
        UpperCAmelCase__							 =						input_ids[-self.model_max_length :]
       return input_ids





