




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    __SCREAMING_SNAKE_CASE				(					lowercase_ )    ->		List[str]:

   """simple docstring"""


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




def    __SCREAMING_SNAKE_CASE				(					lowercase_ )    ->		int:

   """simple docstring"""


   __UpperCamelCase											=  {}
   __UpperCamelCase											=  (
       LoRAAttnProcessor2_0 if hasattr(lowercase_   ,       '''scaled_dot_product_attention''' ) else LoRAAttnProcessor
   )
   for name, module in text_encoder.named_modules():
      if name.endswith(lowercase_ ):
         __UpperCamelCase											=  lora_attn_processor_class(
             hidden_size=module.out_proj.out_features   ,       cross_attention_dim=lowercase_ )
   return text_lora_attn_procs




def    __SCREAMING_SNAKE_CASE				(					lowercase_ )    ->		Tuple:

   """simple docstring"""


   __UpperCamelCase											=  create_text_encoder_lora_attn_procs(lowercase_ )
   __UpperCamelCase											=  AttnProcsLayers(lowercase_ )
   return text_encoder_lora_layers




def    __SCREAMING_SNAKE_CASE				(					lowercase_   ,       lowercase_=False )    ->		Dict:

   """simple docstring"""


   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''' ):
            __UpperCamelCase											=  (
                torch.randn_like(layer_module.up.weight )
                if randn_weight
                else torch.zeros_like(layer_module.up.weight )
            )
            __UpperCamelCase											=  torch.nn.Parameter(lowercase_ )


class 	_lowerCamelCase  (     unittest.TestCase				):

      """simple docstring"""

      def  snake_case		(       self   :	Dict			):
         torch.manual_seed(0			)
         __UpperCamelCase											=  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	,    )
         __UpperCamelCase											=  DDIMScheduler(
             beta_start=0.0_00_85	,    beta_end=0.0_12	,    beta_schedule='''scaled_linear'''	,    clip_sample=_UpperCAmelCase	,    set_alpha_to_one=_UpperCAmelCase	,    steps_offset=1	,    )
         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	,    )
         __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	,    )
         __UpperCamelCase											=  CLIPTextModel(_UpperCAmelCase			)
         __UpperCamelCase											=  CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''			)

         __UpperCamelCase						, __UpperCamelCase											=  create_unet_lora_layers(_UpperCAmelCase			)
         __UpperCamelCase											=  create_text_encoder_lora_layers(_UpperCAmelCase			)

         __UpperCamelCase											=  {
             '''unet''': unet,
             '''scheduler''': scheduler,
             '''vae''': vae,
             '''text_encoder''': text_encoder,
             '''tokenizer''': tokenizer,
             '''safety_checker''': None,
             '''feature_extractor''': None,
         }
         __UpperCamelCase											=  {
             '''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  snake_case		(       self   :	Union[str, Any]			):
         __UpperCamelCase											=  1
         __UpperCamelCase											=  10
         __UpperCamelCase											=  4
         __UpperCamelCase											=  (32, 32)

         __UpperCamelCase											=  torch.manual_seed(0			)
         __UpperCamelCase											=  floats_tensor((batch_size, num_channels) + sizes			)
         __UpperCamelCase											=  torch.randint(1	,    _UpperCAmelCase	,    size=(batch_size, sequence_length)	,    generator=_UpperCAmelCase			)

         __UpperCamelCase											=  {
             '''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  snake_case		(       self   :	int			):
         __UpperCamelCase											=  77

         __UpperCamelCase											=  torch.randint(2	,    56	,    size=(1, max_seq_length)	,    generator=torch.manual_seed(0			)			)

         __UpperCamelCase											=  {}
         __UpperCamelCase											=  inputs
         return prepared_inputs







      def  snake_case		(       self   :	Union[str, Any]	,    snake_case   :	str			):
         __UpperCamelCase						, __UpperCamelCase											=  self.get_dummy_components()
         LoraLoaderMixin.save_lora_weights(
             save_directory=_UpperCAmelCase	,    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(_UpperCAmelCase	,    '''pytorch_lora_weights.bin'''			)			)			)







      def  snake_case		(       self   :	Any			):
         __UpperCamelCase						, __UpperCamelCase											=  self.get_dummy_components()
         __UpperCamelCase											=  StableDiffusionPipeline(**_UpperCAmelCase			)
         __UpperCamelCase											=  sd_pipe.to(_UpperCAmelCase			)
         sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase			)

         __UpperCamelCase						, __UpperCamelCase						, __UpperCamelCase											=  self.get_dummy_inputs()

         __UpperCamelCase											=  sd_pipe(**_UpperCAmelCase			).images
         __UpperCamelCase											=  original_images[0, -3:, -3:, -1]

         with tempfile.TemporaryDirectory() as tmpdirname:
            LoraLoaderMixin.save_lora_weights(
                save_directory=_UpperCAmelCase	,    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(_UpperCAmelCase	,    '''pytorch_lora_weights.bin'''			)			)			)
            sd_pipe.load_lora_weights(_UpperCAmelCase			)

         __UpperCamelCase											=  sd_pipe(**_UpperCAmelCase			).images
         __UpperCamelCase											=  lora_images[0, -3:, -3:, -1]

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







      def  snake_case		(       self   :	List[Any]			):
         __UpperCamelCase						, __UpperCamelCase											=  self.get_dummy_components()
         __UpperCamelCase											=  StableDiffusionPipeline(**_UpperCAmelCase			)
         __UpperCamelCase											=  sd_pipe.to(_UpperCAmelCase			)
         sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase			)

         __UpperCamelCase						, __UpperCamelCase						, __UpperCamelCase											=  self.get_dummy_inputs()

         __UpperCamelCase											=  sd_pipe(**_UpperCAmelCase			).images
         __UpperCamelCase											=  original_images[0, -3:, -3:, -1]

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

         __UpperCamelCase											=  sd_pipe(**_UpperCAmelCase			).images
         __UpperCamelCase											=  lora_images[0, -3:, -3:, -1]

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







      def  snake_case		(       self   :	Any			):
         __UpperCamelCase						, __UpperCamelCase											=  self.get_dummy_components()
         __UpperCamelCase											=  lora_components['''unet_lora_attn_procs''']
         __UpperCamelCase											=  StableDiffusionPipeline(**_UpperCAmelCase			)
         __UpperCamelCase											=  sd_pipe.to(_UpperCAmelCase			)
         sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase			)

         __UpperCamelCase						, __UpperCamelCase						, __UpperCamelCase											=  self.get_dummy_inputs()

         __UpperCamelCase											=  sd_pipe(**_UpperCAmelCase			).images
         __UpperCamelCase											=  original_images[0, -3:, -3:, -1]

         with tempfile.TemporaryDirectory() as tmpdirname:
            __UpperCamelCase											=  sd_pipe.unet
            unet.set_attn_processor(_UpperCAmelCase			)
            unet.save_attn_procs(_UpperCAmelCase			)
            self.assertTrue(os.path.isfile(os.path.join(_UpperCAmelCase	,    '''pytorch_lora_weights.bin'''			)			)			)
            sd_pipe.load_lora_weights(_UpperCAmelCase			)

         __UpperCamelCase											=  sd_pipe(**_UpperCAmelCase			).images
         __UpperCamelCase											=  lora_images[0, -3:, -3:, -1]

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







      def  snake_case		(       self   :	List[str]			):
         __UpperCamelCase						, __UpperCamelCase											=  self.get_dummy_components()
         __UpperCamelCase											=  StableDiffusionPipeline(**_UpperCAmelCase			)

         __UpperCamelCase											=  self.get_dummy_tokens()

         # inference without lora
         __UpperCamelCase											=  pipe.text_encoder(**_UpperCAmelCase			)[0]
         assert outputs_without_lora.shape == (1, 77, 32)

         # create lora_attn_procs with zeroed out up.weights
         __UpperCamelCase											=  create_text_encoder_lora_attn_procs(pipe.text_encoder			)
         set_lora_up_weights(_UpperCAmelCase	,    randn_weight=_UpperCAmelCase			)

         # monkey patch
         pipe._modify_text_encoder(_UpperCAmelCase			)

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

         # inference with lora
         __UpperCamelCase											=  pipe.text_encoder(**_UpperCAmelCase			)[0]
         assert outputs_with_lora.shape == (1, 77, 32)

         assert torch.allclose(
             _UpperCAmelCase	,    _UpperCAmelCase			), "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
         __UpperCamelCase											=  create_text_encoder_lora_attn_procs(pipe.text_encoder			)
         set_lora_up_weights(_UpperCAmelCase	,    randn_weight=_UpperCAmelCase			)

         # monkey patch
         pipe._modify_text_encoder(_UpperCAmelCase			)

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

         # inference with lora
         __UpperCamelCase											=  pipe.text_encoder(**_UpperCAmelCase			)[0]
         assert outputs_with_lora.shape == (1, 77, 32)

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







      def  snake_case		(       self   :	List[Any]			):
         __UpperCamelCase						, __UpperCamelCase											=  self.get_dummy_components()
         __UpperCamelCase											=  StableDiffusionPipeline(**_UpperCAmelCase			)

         __UpperCamelCase											=  self.get_dummy_tokens()

         # inference without lora
         __UpperCamelCase											=  pipe.text_encoder(**_UpperCAmelCase			)[0]
         assert outputs_without_lora.shape == (1, 77, 32)

         # create lora_attn_procs with randn up.weights
         __UpperCamelCase											=  create_text_encoder_lora_attn_procs(pipe.text_encoder			)
         set_lora_up_weights(_UpperCAmelCase	,    randn_weight=_UpperCAmelCase			)

         # monkey patch
         pipe._modify_text_encoder(_UpperCAmelCase			)

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

         # inference with lora
         __UpperCamelCase											=  pipe.text_encoder(**_UpperCAmelCase			)[0]
         assert outputs_with_lora.shape == (1, 77, 32)

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

         # remove monkey patch
         pipe._remove_text_encoder_monkey_patch()

         # inference with removed lora
         __UpperCamelCase											=  pipe.text_encoder(**_UpperCAmelCase			)[0]
         assert outputs_without_lora_removed.shape == (1, 77, 32)

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







      def  snake_case		(       self   :	List[str]			):
         __UpperCamelCase						, __UpperCamelCase											=  self.get_dummy_components()
         __UpperCamelCase											=  StableDiffusionPipeline(**_UpperCAmelCase			)
         __UpperCamelCase											=  sd_pipe.to(_UpperCAmelCase			)
         sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase			)

         __UpperCamelCase						, __UpperCamelCase						, __UpperCamelCase											=  self.get_dummy_inputs()

         with tempfile.TemporaryDirectory() as tmpdirname:
            LoraLoaderMixin.save_lora_weights(
                save_directory=_UpperCAmelCase	,    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(_UpperCAmelCase	,    '''pytorch_lora_weights.bin'''			)			)			)
            sd_pipe.load_lora_weights(_UpperCAmelCase			)

         __UpperCamelCase											=  sd_pipe(**_UpperCAmelCase			).images
         __UpperCamelCase											=  lora_images[0, -3:, -3:, -1]

         __UpperCamelCase											=  sd_pipe(**_UpperCAmelCase	,    cross_attention_kwargs={'''scale''': 0.5}			).images
         __UpperCamelCase											=  lora_images_with_scale[0, -3:, -3:, -1]

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







      def  snake_case		(       self   :	List[Any]			):


         with tempfile.TemporaryDirectory() as tmpdirname:
            self.create_lora_weight_file(_UpperCAmelCase			)

            __UpperCamelCase						, __UpperCamelCase											=  self.get_dummy_components()
            __UpperCamelCase											=  StableDiffusionPipeline(**_UpperCAmelCase			)
            __UpperCamelCase											=  sd_pipe.to(_UpperCAmelCase			)
            sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase			)

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

            # load LoRA weight file
            sd_pipe.load_lora_weights(_UpperCAmelCase			)

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







      @unittest.skipIf(torch_device != '''cuda'''	,    '''This test is supposed to run on GPU'''			)
      def  snake_case		(       self   :	Tuple			):


         with tempfile.TemporaryDirectory() as tmpdirname:
            self.create_lora_weight_file(_UpperCAmelCase			)

            __UpperCamelCase						, __UpperCamelCase											=  self.get_dummy_components()
            __UpperCamelCase											=  StableDiffusionPipeline(**_UpperCAmelCase			)
            __UpperCamelCase											=  sd_pipe.to(_UpperCAmelCase			)
            sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase			)

            # 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(_UpperCAmelCase	,    _UpperCAmelCase			):
                  self.assertIsInstance(module.processor	,    _UpperCAmelCase			)

            # load LoRA weight file
            sd_pipe.load_lora_weights(_UpperCAmelCase			)

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







      @unittest.skipIf(torch_device != '''cuda'''	,    '''This test is supposed to run on GPU'''			)
      def  snake_case		(       self   :	List[str]			):
         __UpperCamelCase						, __UpperCamelCase											=  self.get_dummy_components()
         __UpperCamelCase											=  StableDiffusionPipeline(**_UpperCAmelCase			)
         __UpperCamelCase											=  sd_pipe.to(_UpperCAmelCase			)
         sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase			)

         __UpperCamelCase						, __UpperCamelCase						, __UpperCamelCase											=  self.get_dummy_inputs()

         # enable XFormers
         sd_pipe.enable_xformers_memory_efficient_attention()

         __UpperCamelCase											=  sd_pipe(**_UpperCAmelCase			).images
         __UpperCamelCase											=  original_images[0, -3:, -3:, -1]

         with tempfile.TemporaryDirectory() as tmpdirname:
            LoraLoaderMixin.save_lora_weights(
                save_directory=_UpperCAmelCase	,    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(_UpperCAmelCase	,    '''pytorch_lora_weights.bin'''			)			)			)
            sd_pipe.load_lora_weights(_UpperCAmelCase			)

         __UpperCamelCase											=  sd_pipe(**_UpperCAmelCase			).images
         __UpperCamelCase											=  lora_images[0, -3:, -3:, -1]

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












# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ..models.auto import AutoModelForSeqaSeqLM, AutoTokenizer
from .base import PipelineTool


a_										=       "Here is a text containing a lot of information: '''{text}'''.\n\nCan you answer this question about the text: '{question}'"

class 	_lowerCamelCase  (     _SCREAMING_SNAKE_CASE				):

      """simple docstring"""

      lowerCAmelCase__     :	Union[str, Any]      =   "google/flan-t5-base"
      lowerCAmelCase__     :	Union[str, Any]      =   (
          "This is a tool that answers questions related to a text. It takes two arguments named `text`, which is the "
          "text where to find the answer, and `question`, which is the question, and returns the answer to the question."
      )
      lowerCAmelCase__     :	List[Any]      =   "text_qa"
      lowerCAmelCase__     :	int      =   AutoTokenizer
      lowerCAmelCase__     :	Optional[Any]      =   AutoModelForSeqaSeqLM

      lowerCAmelCase__     :	Tuple      =   ["text", "text"]
      lowerCAmelCase__     :	Any      =   ["text"]







      def  snake_case		(       self   :	Union[str, Any]	,    snake_case   :	str	,    snake_case   :	str			):
          __UpperCamelCase											=  QA_PROMPT.format(text=snake_case	,    question=snake_case			)
          return self.pre_processor(snake_case	,    return_tensors='''pt'''			)







      def  snake_case		(       self   :	Any	,    snake_case   :	Optional[int]			):
          __UpperCamelCase											=  self.model.generate(**snake_case			)

          __UpperCamelCase						, __UpperCamelCase											=  inputs['''input_ids'''].shape
          __UpperCamelCase											=  output_ids.shape[0]

          return output_ids.reshape(snake_case	,    out_b // in_b	,    *output_ids.shape[1:]			)[0][0]







      def  snake_case		(       self   :	Tuple	,    snake_case   :	Optional[Any]			):
          return self.pre_processor.decode(snake_case	,    skip_special_tokens=snake_case	,    clean_up_tokenization_spaces=snake_case			)






