






'''simple docstring'''


import enum
import inspect
import warnings
from functools import wraps
from typing import Callable, Optional

from .logging import get_logger


SCREAMING_SNAKE_CASE_				      =							set()
SCREAMING_SNAKE_CASE_				      =							get_logger(__name__)






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__ = None		):

 def decorator(SCREAMING_SNAKE_CASE__		):
  global _emitted_deprecation_warnings

  if inspect.isclass(SCREAMING_SNAKE_CASE__		):
   __a    :	Optional[Any]									=						deprecated_class_or_function.__init__
   __a    :	Optional[int]									=						deprecated_class_or_function.__name__
  else:
   __a    :	List[Any]									=						deprecated_class_or_function
   __a    :	Dict									=						deprecated_function.__name__
   # Support deprecating __init__ class method: class name instead
   __a    :	Union[str, Any]									=						name if name != '__init__' else deprecated_function.__qualname__.split('.'		)[-2]

  __a    :	str									=						(
      f'''{name} is deprecated and will be removed in the next major version of datasets.''' + f''' {help_message}'''
      if help_message
      else ''
  )

  @wraps(SCREAMING_SNAKE_CASE__		)
  def wrapper(*SCREAMING_SNAKE_CASE__       ,		**SCREAMING_SNAKE_CASE__		):
   __a    :	List[Any]									=						hash(SCREAMING_SNAKE_CASE__		)
   if func_hash not in _emitted_deprecation_warnings:
    warnings.warn(SCREAMING_SNAKE_CASE__       ,		category=SCREAMING_SNAKE_CASE__       ,		stacklevel=2		)
    _emitted_deprecation_warnings.add(SCREAMING_SNAKE_CASE__		)
   return deprecated_function(*SCREAMING_SNAKE_CASE__       ,		**SCREAMING_SNAKE_CASE__		)

  __a    :	int									=						'deprecated'

  if inspect.isclass(SCREAMING_SNAKE_CASE__		):
   __a    :	str									=						wrapper
   return deprecated_class_or_function
  else:
   return wrapper

 return decorator




class 							lowerCAmelCase					(							enum.EnumMeta   ):







   """simple docstring"""







   def __getattribute__( cls   ,   _A			)    ->   Dict:
    __a    :	Optional[Any]									=						super().__getattribute__(_A			)
    if isinstance(_A   ,   enum.Enum			) and obj._on_access:
     obj._on_access()
    return obj



   def __getitem__( cls   ,   _A			)    ->   Any:
    __a    :	Dict									=						super().__getitem__(_A			)
    if member._on_access:
     member._on_access()
    return member



   def __call__( cls   ,   _A   ,   _A=None   ,   *, _A=None   ,   _A=None   ,   _A=None   ,   _A=1			)    ->   Tuple:
    __a    :	List[Any]									=						super().__call__(_A   ,   _A   ,   module=_A   ,   qualname=_A   ,   type=_A   ,   start=_A			)
    if isinstance(_A   ,   enum.Enum			) and obj._on_access:
     obj._on_access()
    return obj




class 							lowerCAmelCase					(							enum.Enum							,      metaclass=lowerCamelCase__   ):







   """simple docstring"""







   def __new__( cls   ,   _A			)    ->   List[str]:
    __a    :	Union[str, Any]									=						object.__new__(cls			)
    __a    :	Any									=						value
    __a    :	List[str]									=						member.deprecate
    return member



   @property
   def    __magic_name__    ( self			)    ->   List[str]:
    return ""



   def    __magic_name__    ( self			)    ->   Any:
    __a    :	Optional[int]									=						f''' {self.help_message}''' if self.help_message else ''
    warnings.warn(
        f'''\'{self.__objclass__.__name__}\' is deprecated and will be removed in the next major version of datasets.'''
        + help_message   ,   _A   ,   stacklevel=3   ,   )












'''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			)			)			)




