






'''simple docstring'''


import os
from shutil import copyfile
from typing import List, Optional, Tuple

from tokenizers import processors

from ...tokenization_utils import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
  from .tokenization_mbartaa import MBartaaTokenizer
else:
  SCREAMING_SNAKE_CASE_				      =							None


SCREAMING_SNAKE_CASE_				      =							logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_				      =							{"vocab_file": "sentencepiece.bpe.model", "tokenizer_file": "tokenizer.json"}

SCREAMING_SNAKE_CASE_				      =							{
    "vocab_file": {
        "facebook/mbart-large-50-one-to-many-mmt": (
            "https://huggingface.co/facebook/mbart-large-50-one-to-many-mmt/resolve/main/sentencepiece.bpe.model"
        ),
    },
    "tokenizer_file": {
        "facebook/mbart-large-50-one-to-many-mmt": (
            "https://huggingface.co/facebook/mbart-large-50-one-to-many-mmt/resolve/main/tokenizer.json"
        ),
    },
}

SCREAMING_SNAKE_CASE_				      =							{
    "facebook/mbart-large-50-one-to-many-mmt": 1_0_2_4,
}

# fmt: off
SCREAMING_SNAKE_CASE_				      =							["ar_AR", "cs_CZ", "de_DE", "en_XX", "es_XX", "et_EE", "fi_FI", "fr_XX", "gu_IN", "hi_IN", "it_IT", "ja_XX", "kk_KZ", "ko_KR", "lt_LT", "lv_LV", "my_MM", "ne_NP", "nl_XX", "ro_RO", "ru_RU", "si_LK", "tr_TR", "vi_VN", "zh_CN", "af_ZA", "az_AZ", "bn_IN", "fa_IR", "he_IL", "hr_HR", "id_ID", "ka_GE", "km_KH", "mk_MK", "ml_IN", "mn_MN", "mr_IN", "pl_PL", "ps_AF", "pt_XX", "sv_SE", "sw_KE", "ta_IN", "te_IN", "th_TH", "tl_XX", "uk_UA", "ur_PK", "xh_ZA", "gl_ES", "sl_SI"]




class 							lowerCAmelCase					(							lowerCamelCase__   ):







   """simple docstring"""







   _A						=   VOCAB_FILES_NAMES
   _A						=   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   _A						=   PRETRAINED_VOCAB_FILES_MAP
   _A						=   ['input_ids', 'attention_mask']
   _A						=   MBartaaTokenizer

   _A						=   []
   _A						=   []



   def __init__( self   ,   _A=None   ,   _A=None   ,   _A=None   ,   _A=None   ,   _A="</s>"   ,   _A="</s>"   ,   _A="<s>"   ,   _A="<unk>"   ,   _A="<pad>"   ,   _A="<mask>"   ,   **_A   ,   )    ->   int:
    # Mask token behave like a normal word, i.e. include the space before it
    __a    :	Union[str, Any]									=						AddedToken(_A   ,   lstrip=_A   ,   rstrip=_A			) if isinstance(_A   ,   _A			) else mask_token

    __a    :	List[str]									=						kwargs.get('additional_special_tokens'   ,   []			)
    kwargs["additional_special_tokens"] += [
        code for code in FAIRSEQ_LANGUAGE_CODES if code not in kwargs["additional_special_tokens"]
    ]

    super().__init__(
        _A   ,   src_lang=_A   ,   tgt_lang=_A   ,   tokenizer_file=_A   ,   eos_token=_A   ,   sep_token=_A   ,   cls_token=_A   ,   unk_token=_A   ,   pad_token=_A   ,   mask_token=_A   ,   **_A   ,   )

    __a    :	int									=						vocab_file
    __a    :	Dict									=						False if not self.vocab_file else True

    __a    :	str									=						{
        lang_code: self.convert_tokens_to_ids(_A			) for lang_code in FAIRSEQ_LANGUAGE_CODES
    }

    __a    :	Tuple									=						src_lang if src_lang is not None else 'en_XX'
    __a    :	Dict									=						tgt_lang
    __a    :	List[Any]									=						self.lang_code_to_id[self._src_lang]
    self.set_src_lang_special_tokens(self._src_lang			)



   @property
   def    __magic_name__    ( self			)    ->   str:
    return self._src_lang



   @src_lang.setter
   def    __magic_name__    ( self   ,   _A			)    ->   None:
    __a    :	List[str]									=						new_src_lang
    self.set_src_lang_special_tokens(self._src_lang			)



   def    __magic_name__    ( self   ,   _A   ,   _A = None			)    ->   List[int]:
    if token_ids_a is None:
     return self.prefix_tokens + token_ids_a + self.suffix_tokens
    # We don't expect to process pairs, but leave the pair logic for API consistency
    return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens



   def    __magic_name__    ( self   ,   _A   ,   _A = "en_XX"   ,   _A = None   ,   _A = "ro_RO"   ,   **_A   ,   )    ->   BatchEncoding:
    __a    :	List[str]									=						src_lang
    __a    :	Dict									=						tgt_lang
    return super().prepare_seqaseq_batch(_A   ,   _A   ,   **_A			)



   def    __magic_name__    ( self			)    ->   Any:
    return self.set_src_lang_special_tokens(self.src_lang			)



   def    __magic_name__    ( self			)    ->   Optional[int]:
    return self.set_tgt_lang_special_tokens(self.tgt_lang			)



   def    __magic_name__    ( self   ,   _A			)    ->   None:
    __a    :	Tuple									=						self.convert_tokens_to_ids(_A			)
    __a    :	Tuple									=						[self.cur_lang_code_id]
    __a    :	List[str]									=						[self.eos_token_id]

    __a    :	Tuple									=						self.convert_ids_to_tokens(self.prefix_tokens			)
    __a    :	Optional[Any]									=						self.convert_ids_to_tokens(self.suffix_tokens			)

    __a    :	str									=						processors.TemplateProcessing(
        single=prefix_tokens_str + ['$A'] + suffix_tokens_str   ,   pair=prefix_tokens_str + ['$A', '$B'] + suffix_tokens_str   ,   special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str   ,   self.prefix_tokens + self.suffix_tokens			)			)   ,   )



   def    __magic_name__    ( self   ,   _A			)    ->   None:
    __a    :	str									=						self.convert_tokens_to_ids(_A			)
    __a    :	List[Any]									=						[self.cur_lang_code_id]
    __a    :	Tuple									=						[self.eos_token_id]

    __a    :	Optional[Any]									=						self.convert_ids_to_tokens(self.prefix_tokens			)
    __a    :	int									=						self.convert_ids_to_tokens(self.suffix_tokens			)

    __a    :	Optional[int]									=						processors.TemplateProcessing(
        single=prefix_tokens_str + ['$A'] + suffix_tokens_str   ,   pair=prefix_tokens_str + ['$A', '$B'] + suffix_tokens_str   ,   special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str   ,   self.prefix_tokens + self.suffix_tokens			)			)   ,   )



   def    __magic_name__    ( self   ,   _A   ,   _A   ,   _A   ,   _A   ,   **_A			)    ->   List[Any]:
    if src_lang is None or tgt_lang is None:
     raise ValueError('Translation requires a `src_lang` and a `tgt_lang` for this model'			)
    __a    :	Union[str, Any]									=						src_lang
    __a    :	str									=						self(_A   ,   add_special_tokens=_A   ,   return_tensors=_A   ,   **_A			)
    __a    :	Optional[Any]									=						self.convert_tokens_to_ids(_A			)
    __a    :	Tuple									=						tgt_lang_id
    return inputs



   def    __magic_name__    ( self   ,   _A   ,   _A = None			)    ->   Tuple[str]:
    if not self.can_save_slow_tokenizer:
     raise ValueError(
         'Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '
         'tokenizer.'			)

    if not os.path.isdir(_A			):
     logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''			)
     return
    __a    :	int									=						os.path.join(
        _A   ,   (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']			)

    if os.path.abspath(self.vocab_file			) != os.path.abspath(_A			):
     copyfile(self.vocab_file   ,   _A			)

    return (out_vocab_file,)









'''simple docstring'''


import gc
import os
import tempfile
import unittest

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
from diffusers.models.attention_processor import (
    Attention,
    AttnProcessor,
    AttnProcessor2_0,
    LoRAAttnProcessor,
    LoRAAttnProcessor2_0,
    LoRAXFormersAttnProcessor,
    XFormersAttnProcessor,
)
from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__		):
 __a    :	List[str]									=						{}
 for name in unet.attn_processors.keys():
  __a    :	int									=						None if name.endswith('attn1.processor'		) else unet.config.cross_attention_dim
  if name.startswith('mid_block'		):
   __a    :	Tuple									=						unet.config.block_out_channels[-1]
  elif name.startswith('up_blocks'		):
   __a    :	int									=						int(name[len('up_blocks.'		)]		)
   __a    :	List[str]									=						list(reversed(unet.config.block_out_channels		)		)[block_id]
  elif name.startswith('down_blocks'		):
   __a    :	int									=						int(name[len('down_blocks.'		)]		)
   __a    :	Optional[Any]									=						unet.config.block_out_channels[block_id]
  __a    :	Optional[int]									=						(
      LoRAAttnProcessor2_0 if hasattr(SCREAMING_SNAKE_CASE__       ,		'scaled_dot_product_attention'		) else LoRAAttnProcessor
  )
  __a    :	Optional[Any]									=						lora_attn_processor_class(
      hidden_size=SCREAMING_SNAKE_CASE__       ,		cross_attention_dim=SCREAMING_SNAKE_CASE__		)
 __a    :	Tuple									=						AttnProcsLayers(SCREAMING_SNAKE_CASE__		)
 return lora_attn_procs, unet_lora_layers






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__		):
 __a    :	Dict									=						{}
 __a    :	int									=						(
     LoRAAttnProcessor2_0 if hasattr(SCREAMING_SNAKE_CASE__       ,		'scaled_dot_product_attention'		) else LoRAAttnProcessor
 )
 for name, module in text_encoder.named_modules():
  if name.endswith(SCREAMING_SNAKE_CASE__		):
   __a    :	Dict									=						lora_attn_processor_class(
       hidden_size=module.out_proj.out_features       ,		cross_attention_dim=SCREAMING_SNAKE_CASE__		)
 return text_lora_attn_procs






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__		):
 __a    :	Tuple									=						create_text_encoder_lora_attn_procs(SCREAMING_SNAKE_CASE__		)
 __a    :	Dict									=						AttnProcsLayers(SCREAMING_SNAKE_CASE__		)
 return text_encoder_lora_layers






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__       ,		SCREAMING_SNAKE_CASE__=False		):
 for _, attn_proc in text_lora_attn_procs.items():
  # set up.weights
  for layer_name, layer_module in attn_proc.named_modules():
   if layer_name.endswith('_lora'		):
    __a    :	Optional[int]									=						(
        torch.randn_like(layer_module.up.weight		)
        if randn_weight
        else torch.zeros_like(layer_module.up.weight		)
    )
    __a    :	int									=						torch.nn.Parameter(SCREAMING_SNAKE_CASE__		)




class 							lowerCAmelCase					(							unittest.TestCase   ):







   """simple docstring"""







   def    __magic_name__    ( self			)    ->   int:
    torch.manual_seed(0			)
    __a    :	str									=						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   ,   )
    __a    :	List[Any]									=						DDIMScheduler(
        beta_start=0.00_085   ,   beta_end=0.012   ,   beta_schedule='scaled_linear'   ,   clip_sample=_A   ,   set_alpha_to_one=_A   ,   steps_offset=1   ,   )
    torch.manual_seed(0			)
    __a    :	Optional[int]									=						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   ,   )
    __a    :	Union[str, Any]									=						CLIPTextConfig(
        bos_token_id=0   ,   eos_token_id=2   ,   hidden_size=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   ,   )
    __a    :	List[Any]									=						CLIPTextModel(_A			)
    __a    :	Dict									=						CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'			)

    __a			,    __a    :	Optional[int]									=						create_unet_lora_layers(_A			)
    __a    :	List[Any]									=						create_text_encoder_lora_layers(_A			)

    __a    :	str									=						{
        'unet': unet,
        'scheduler': scheduler,
        'vae': vae,
        'text_encoder': text_encoder,
        'tokenizer': tokenizer,
        'safety_checker': None,
        'feature_extractor': None,
    }
    __a    :	Optional[Any]									=						{
        'unet_lora_layers': unet_lora_layers,
        'text_encoder_lora_layers': text_encoder_lora_layers,
        'unet_lora_attn_procs': unet_lora_attn_procs,
    }
    return pipeline_components, lora_components



   def    __magic_name__    ( self			)    ->   Optional[Any]:
    __a    :	int									=						1
    __a    :	Tuple									=						10
    __a    :	int									=						4
    __a    :	List[str]									=						(32, 32)

    __a    :	Tuple									=						torch.manual_seed(0			)
    __a    :	Tuple									=						floats_tensor((batch_size, num_channels) + sizes			)
    __a    :	Tuple									=						torch.randint(1   ,   _A   ,   size=(batch_size, sequence_length)   ,   generator=_A			)

    __a    :	Union[str, Any]									=						{
        'prompt': 'A painting of a squirrel eating a burger',
        'generator': generator,
        'num_inference_steps': 2,
        'guidance_scale': 6.0,
        'output_type': 'numpy',
    }

    return noise, input_ids, pipeline_inputs

    # copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb



   def    __magic_name__    ( self			)    ->   Optional[int]:
    __a    :	Optional[Any]									=						77

    __a    :	Union[str, Any]									=						torch.randint(2   ,   56   ,   size=(1, max_seq_length)   ,   generator=torch.manual_seed(0			)			)

    __a    :	Optional[int]									=						{}
    __a    :	Tuple									=						inputs
    return prepared_inputs



   def    __magic_name__    ( self   ,   _A			)    ->   Optional[int]:
    __a			,    __a    :	Dict									=						self.get_dummy_components()
    LoraLoaderMixin.save_lora_weights(
        save_directory=_A   ,   unet_lora_layers=lora_components['unet_lora_layers']   ,   text_encoder_lora_layers=lora_components['text_encoder_lora_layers']   ,   )
    self.assertTrue(os.path.isfile(os.path.join(_A   ,   'pytorch_lora_weights.bin'			)			)			)



   def    __magic_name__    ( self			)    ->   str:
    __a			,    __a    :	Dict									=						self.get_dummy_components()
    __a    :	List[Any]									=						StableDiffusionPipeline(**_A			)
    __a    :	List[Any]									=						sd_pipe.to(_A			)
    sd_pipe.set_progress_bar_config(disable=_A			)

    __a			,    __a			,    __a    :	List[Any]									=						self.get_dummy_inputs()

    __a    :	Dict									=						sd_pipe(**_A			).images
    __a    :	Optional[int]									=						original_images[0, -3:, -3:, -1]

    with tempfile.TemporaryDirectory() as tmpdirname:
     LoraLoaderMixin.save_lora_weights(
         save_directory=_A   ,   unet_lora_layers=lora_components['unet_lora_layers']   ,   text_encoder_lora_layers=lora_components['text_encoder_lora_layers']   ,   )
     self.assertTrue(os.path.isfile(os.path.join(_A   ,   'pytorch_lora_weights.bin'			)			)			)
     sd_pipe.load_lora_weights(_A			)

    __a    :	str									=						sd_pipe(**_A			).images
    __a    :	Optional[Any]									=						lora_images[0, -3:, -3:, -1]

    # Outputs shouldn't match.
    self.assertFalse(torch.allclose(torch.from_numpy(_A			)   ,   torch.from_numpy(_A			)			)			)



   def    __magic_name__    ( self			)    ->   Tuple:
    __a			,    __a    :	List[str]									=						self.get_dummy_components()
    __a    :	Any									=						StableDiffusionPipeline(**_A			)
    __a    :	str									=						sd_pipe.to(_A			)
    sd_pipe.set_progress_bar_config(disable=_A			)

    __a			,    __a			,    __a    :	str									=						self.get_dummy_inputs()

    __a    :	Optional[Any]									=						sd_pipe(**_A			).images
    __a    :	Tuple									=						original_images[0, -3:, -3:, -1]

    with tempfile.TemporaryDirectory() as tmpdirname:
     LoraLoaderMixin.save_lora_weights(
         save_directory=_A   ,   unet_lora_layers=lora_components['unet_lora_layers']   ,   text_encoder_lora_layers=lora_components['text_encoder_lora_layers']   ,   safe_serialization=_A   ,   )
     self.assertTrue(os.path.isfile(os.path.join(_A   ,   'pytorch_lora_weights.safetensors'			)			)			)
     sd_pipe.load_lora_weights(_A			)

    __a    :	str									=						sd_pipe(**_A			).images
    __a    :	int									=						lora_images[0, -3:, -3:, -1]

    # Outputs shouldn't match.
    self.assertFalse(torch.allclose(torch.from_numpy(_A			)   ,   torch.from_numpy(_A			)			)			)



   def    __magic_name__    ( self			)    ->   Optional[Any]:
    __a			,    __a    :	Optional[int]									=						self.get_dummy_components()
    __a    :	List[Any]									=						lora_components['unet_lora_attn_procs']
    __a    :	Union[str, Any]									=						StableDiffusionPipeline(**_A			)
    __a    :	Optional[Any]									=						sd_pipe.to(_A			)
    sd_pipe.set_progress_bar_config(disable=_A			)

    __a			,    __a			,    __a    :	Union[str, Any]									=						self.get_dummy_inputs()

    __a    :	List[Any]									=						sd_pipe(**_A			).images
    __a    :	Union[str, Any]									=						original_images[0, -3:, -3:, -1]

    with tempfile.TemporaryDirectory() as tmpdirname:
     __a    :	Optional[Any]									=						sd_pipe.unet
     unet.set_attn_processor(_A			)
     unet.save_attn_procs(_A			)
     self.assertTrue(os.path.isfile(os.path.join(_A   ,   'pytorch_lora_weights.bin'			)			)			)
     sd_pipe.load_lora_weights(_A			)

    __a    :	Optional[Any]									=						sd_pipe(**_A			).images
    __a    :	Any									=						lora_images[0, -3:, -3:, -1]

    # Outputs shouldn't match.
    self.assertFalse(torch.allclose(torch.from_numpy(_A			)   ,   torch.from_numpy(_A			)			)			)



   def    __magic_name__    ( self			)    ->   int:
    __a			,    __a    :	Dict									=						self.get_dummy_components()
    __a    :	Optional[int]									=						StableDiffusionPipeline(**_A			)

    __a    :	List[Any]									=						self.get_dummy_tokens()

    # inference without lora
    __a    :	List[Any]									=						pipe.text_encoder(**_A			)[0]
    assert outputs_without_lora.shape == (1, 77, 32)

    # create lora_attn_procs with zeroed out up.weights
    __a    :	int									=						create_text_encoder_lora_attn_procs(pipe.text_encoder			)
    set_lora_up_weights(_A   ,   randn_weight=_A			)

    # monkey patch
    pipe._modify_text_encoder(_A			)

    # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
    del text_attn_procs
    gc.collect()

    # inference with lora
    __a    :	Union[str, Any]									=						pipe.text_encoder(**_A			)[0]
    assert outputs_with_lora.shape == (1, 77, 32)

    assert torch.allclose(
        _A   ,   _A			), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"

    # create lora_attn_procs with randn up.weights
    __a    :	Optional[int]									=						create_text_encoder_lora_attn_procs(pipe.text_encoder			)
    set_lora_up_weights(_A   ,   randn_weight=_A			)

    # monkey patch
    pipe._modify_text_encoder(_A			)

    # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
    del text_attn_procs
    gc.collect()

    # inference with lora
    __a    :	List[str]									=						pipe.text_encoder(**_A			)[0]
    assert outputs_with_lora.shape == (1, 77, 32)

    assert not torch.allclose(
        _A   ,   _A			), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"



   def    __magic_name__    ( self			)    ->   Union[str, Any]:
    __a			,    __a    :	List[str]									=						self.get_dummy_components()
    __a    :	str									=						StableDiffusionPipeline(**_A			)

    __a    :	Tuple									=						self.get_dummy_tokens()

    # inference without lora
    __a    :	Tuple									=						pipe.text_encoder(**_A			)[0]
    assert outputs_without_lora.shape == (1, 77, 32)

    # create lora_attn_procs with randn up.weights
    __a    :	Optional[int]									=						create_text_encoder_lora_attn_procs(pipe.text_encoder			)
    set_lora_up_weights(_A   ,   randn_weight=_A			)

    # monkey patch
    pipe._modify_text_encoder(_A			)

    # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
    del text_attn_procs
    gc.collect()

    # inference with lora
    __a    :	int									=						pipe.text_encoder(**_A			)[0]
    assert outputs_with_lora.shape == (1, 77, 32)

    assert not torch.allclose(
        _A   ,   _A			), "lora outputs should be different to without lora outputs"

    # remove monkey patch
    pipe._remove_text_encoder_monkey_patch()

    # inference with removed lora
    __a    :	Union[str, Any]									=						pipe.text_encoder(**_A			)[0]
    assert outputs_without_lora_removed.shape == (1, 77, 32)

    assert torch.allclose(
        _A   ,   _A			), "remove lora monkey patch should restore the original outputs"



   def    __magic_name__    ( self			)    ->   Dict:
    __a			,    __a    :	Dict									=						self.get_dummy_components()
    __a    :	Optional[Any]									=						StableDiffusionPipeline(**_A			)
    __a    :	int									=						sd_pipe.to(_A			)
    sd_pipe.set_progress_bar_config(disable=_A			)

    __a			,    __a			,    __a    :	Any									=						self.get_dummy_inputs()

    with tempfile.TemporaryDirectory() as tmpdirname:
     LoraLoaderMixin.save_lora_weights(
         save_directory=_A   ,   unet_lora_layers=lora_components['unet_lora_layers']   ,   text_encoder_lora_layers=lora_components['text_encoder_lora_layers']   ,   )
     self.assertTrue(os.path.isfile(os.path.join(_A   ,   'pytorch_lora_weights.bin'			)			)			)
     sd_pipe.load_lora_weights(_A			)

    __a    :	int									=						sd_pipe(**_A			).images
    __a    :	Any									=						lora_images[0, -3:, -3:, -1]

    __a    :	Optional[int]									=						sd_pipe(**_A   ,   cross_attention_kwargs={'scale': 0.5}			).images
    __a    :	str									=						lora_images_with_scale[0, -3:, -3:, -1]

    # Outputs shouldn't match.
    self.assertFalse(
        torch.allclose(torch.from_numpy(_A			)   ,   torch.from_numpy(_A			)			)			)



   def    __magic_name__    ( self			)    ->   str:
    with tempfile.TemporaryDirectory() as tmpdirname:
     self.create_lora_weight_file(_A			)

     __a			,    __a    :	Union[str, Any]									=						self.get_dummy_components()
     __a    :	List[str]									=						StableDiffusionPipeline(**_A			)
     __a    :	List[str]									=						sd_pipe.to(_A			)
     sd_pipe.set_progress_bar_config(disable=_A			)

     # check if vanilla attention processors are used
     for _, module in sd_pipe.unet.named_modules():
      if isinstance(_A   ,   _A			):
       self.assertIsInstance(module.processor   ,   (AttnProcessor, AttnProcessor2_0)			)

            # load LoRA weight file
     sd_pipe.load_lora_weights(_A			)

     # check if lora attention processors are used
     for _, module in sd_pipe.unet.named_modules():
      if isinstance(_A   ,   _A			):
       __a    :	str									=						(
           LoRAAttnProcessor2_0 if hasattr(_A   ,   'scaled_dot_product_attention'			) else LoRAAttnProcessor
       )
       self.assertIsInstance(module.processor   ,   _A			)



   @unittest.skipIf(torch_device != 'cuda'   ,   'This test is supposed to run on GPU'			)
   def    __magic_name__    ( self			)    ->   Union[str, Any]:
    with tempfile.TemporaryDirectory() as tmpdirname:
     self.create_lora_weight_file(_A			)

     __a			,    __a    :	Optional[int]									=						self.get_dummy_components()
     __a    :	Tuple									=						StableDiffusionPipeline(**_A			)
     __a    :	Optional[int]									=						sd_pipe.to(_A			)
     sd_pipe.set_progress_bar_config(disable=_A			)

     # enable XFormers
     sd_pipe.enable_xformers_memory_efficient_attention()

     # check if xFormers attention processors are used
     for _, module in sd_pipe.unet.named_modules():
      if isinstance(_A   ,   _A			):
       self.assertIsInstance(module.processor   ,   _A			)

            # load LoRA weight file
     sd_pipe.load_lora_weights(_A			)

     # check if lora attention processors are used
     for _, module in sd_pipe.unet.named_modules():
      if isinstance(_A   ,   _A			):
       self.assertIsInstance(module.processor   ,   _A			)



   @unittest.skipIf(torch_device != 'cuda'   ,   'This test is supposed to run on GPU'			)
   def    __magic_name__    ( self			)    ->   Union[str, Any]:
    __a			,    __a    :	Union[str, Any]									=						self.get_dummy_components()
    __a    :	Tuple									=						StableDiffusionPipeline(**_A			)
    __a    :	str									=						sd_pipe.to(_A			)
    sd_pipe.set_progress_bar_config(disable=_A			)

    __a			,    __a			,    __a    :	Optional[Any]									=						self.get_dummy_inputs()

    # enable XFormers
    sd_pipe.enable_xformers_memory_efficient_attention()

    __a    :	str									=						sd_pipe(**_A			).images
    __a    :	str									=						original_images[0, -3:, -3:, -1]

    with tempfile.TemporaryDirectory() as tmpdirname:
     LoraLoaderMixin.save_lora_weights(
         save_directory=_A   ,   unet_lora_layers=lora_components['unet_lora_layers']   ,   text_encoder_lora_layers=lora_components['text_encoder_lora_layers']   ,   )
     self.assertTrue(os.path.isfile(os.path.join(_A   ,   'pytorch_lora_weights.bin'			)			)			)
     sd_pipe.load_lora_weights(_A			)

    __a    :	Union[str, Any]									=						sd_pipe(**_A			).images
    __a    :	str									=						lora_images[0, -3:, -3:, -1]

    # Outputs shouldn't match.
    self.assertFalse(torch.allclose(torch.from_numpy(_A			)   ,   torch.from_numpy(_A			)			)			)




