




# This model implementation is heavily based on:

import gc
import random
import tempfile
import unittest

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

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetInpaintPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
    TEXT_TO_IMAGE_IMAGE_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()

class 	_lowerCamelCase  (     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     unittest.TestCase				):

      """simple docstring"""

      lowerCAmelCase__     :	str      =   StableDiffusionControlNetInpaintPipeline
      lowerCAmelCase__     :	List[Any]      =   TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
      lowerCAmelCase__     :	Tuple      =   TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
      lowerCAmelCase__     :	Tuple      =   frozenset({"control_image"}				)  # skip `image` and `mask` for now, only test for control_image
      lowerCAmelCase__     :	Any      =   TEXT_TO_IMAGE_IMAGE_PARAMS







      def  snake_case		(       self   :	Optional[Any]			):
          torch.manual_seed(0			)
          __UpperCamelCase											=  UNetaDConditionModel(
              block_out_channels=(32, 64)	,    layers_per_block=2	,    sample_size=32	,    in_channels=9	,    out_channels=4	,    down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')	,    up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')	,    cross_attention_dim=32	,    )
          torch.manual_seed(0			)
          __UpperCamelCase											=  ControlNetModel(
              block_out_channels=(32, 64)	,    layers_per_block=2	,    in_channels=4	,    down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')	,    cross_attention_dim=32	,    conditioning_embedding_out_channels=(16, 32)	,    )
          torch.manual_seed(0			)
          __UpperCamelCase											=  DDIMScheduler(
              beta_start=0.0_00_85	,    beta_end=0.0_12	,    beta_schedule='''scaled_linear'''	,    clip_sample=snake_case	,    set_alpha_to_one=snake_case	,    )
          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	,    )
          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	,    )
          __UpperCamelCase											=  CLIPTextModel(snake_case			)
          __UpperCamelCase											=  CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''			)

          __UpperCamelCase											=  {
              '''unet''': unet,
              '''controlnet''': controlnet,
              '''scheduler''': scheduler,
              '''vae''': vae,
              '''text_encoder''': text_encoder,
              '''tokenizer''': tokenizer,
              '''safety_checker''': None,
              '''feature_extractor''': None,
          }
          return components







      def  snake_case		(       self   :	int	,    snake_case   :	List[Any]	,    snake_case   :	Union[str, Any]=0			):
          if str(snake_case			).startswith('''mps'''			):
              __UpperCamelCase											=  torch.manual_seed(snake_case			)
          else:
              __UpperCamelCase											=  torch.Generator(device=snake_case			).manual_seed(snake_case			)

          __UpperCamelCase											=  2
          __UpperCamelCase											=  randn_tensor(
              (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)	,    generator=snake_case	,    device=torch.device(snake_case			)	,    )
          __UpperCamelCase											=  floats_tensor((1, 3, 32, 32)	,    rng=random.Random(snake_case			)			).to(snake_case			)
          __UpperCamelCase											=  init_image.cpu().permute(0	,    2	,    3	,    1			)[0]

          __UpperCamelCase											=  Image.fromarray(np.uinta(snake_case			)			).convert('''RGB'''			).resize((64, 64)			)
          __UpperCamelCase											=  Image.fromarray(np.uinta(init_image + 4			)			).convert('''RGB'''			).resize((64, 64)			)

          __UpperCamelCase											=  {
              '''prompt''': '''A painting of a squirrel eating a burger''',
              '''generator''': generator,
              '''num_inference_steps''': 2,
              '''guidance_scale''': 6.0,
              '''output_type''': '''numpy''',
              '''image''': image,
              '''mask_image''': mask_image,
              '''control_image''': control_image,
          }

          return inputs







      def  snake_case		(       self   :	Optional[int]			):
          return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3			)







      @unittest.skipIf(
          torch_device != '''cuda''' or not is_xformers_available()	,    reason='''XFormers attention is only available with CUDA and `xformers` installed'''	,    )
      def  snake_case		(       self   :	Optional[int]			):
          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3			)







      def  snake_case		(       self   :	str			):
          self._test_inference_batch_single_identical(expected_max_diff=2E-3			)







class 	_lowerCamelCase  (     _SCREAMING_SNAKE_CASE				):

      """simple docstring"""

      lowerCAmelCase__     :	Dict      =   StableDiffusionControlNetInpaintPipeline
      lowerCAmelCase__     :	int      =   TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
      lowerCAmelCase__     :	Union[str, Any]      =   TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
      lowerCAmelCase__     :	Union[str, Any]      =   frozenset([]				)







      def  snake_case		(       self   :	Tuple			):
          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	,    )
          torch.manual_seed(0			)
          __UpperCamelCase											=  ControlNetModel(
              block_out_channels=(32, 64)	,    layers_per_block=2	,    in_channels=4	,    down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')	,    cross_attention_dim=32	,    conditioning_embedding_out_channels=(16, 32)	,    )
          torch.manual_seed(0			)
          __UpperCamelCase											=  DDIMScheduler(
              beta_start=0.0_00_85	,    beta_end=0.0_12	,    beta_schedule='''scaled_linear'''	,    clip_sample=snake_case	,    set_alpha_to_one=snake_case	,    )
          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	,    )
          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	,    )
          __UpperCamelCase											=  CLIPTextModel(snake_case			)
          __UpperCamelCase											=  CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''			)

          __UpperCamelCase											=  {
              '''unet''': unet,
              '''controlnet''': controlnet,
              '''scheduler''': scheduler,
              '''vae''': vae,
              '''text_encoder''': text_encoder,
              '''tokenizer''': tokenizer,
              '''safety_checker''': None,
              '''feature_extractor''': None,
          }
          return components







class 	_lowerCamelCase  (     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     unittest.TestCase				):

      """simple docstring"""

      lowerCAmelCase__     :	str      =   StableDiffusionControlNetInpaintPipeline
      lowerCAmelCase__     :	int      =   TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
      lowerCAmelCase__     :	Any      =   TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS







      def  snake_case		(       self   :	str			):
          torch.manual_seed(0			)
          __UpperCamelCase											=  UNetaDConditionModel(
              block_out_channels=(32, 64)	,    layers_per_block=2	,    sample_size=32	,    in_channels=9	,    out_channels=4	,    down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')	,    up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')	,    cross_attention_dim=32	,    )
          torch.manual_seed(0			)

          def init_weights(snake_case   :	int			):
              if isinstance(snake_case	,    torch.nn.Convad			):
                  torch.nn.init.normal(m.weight			)
                  m.bias.data.fill_(1.0			)

          __UpperCamelCase											=  ControlNetModel(
              block_out_channels=(32, 64)	,    layers_per_block=2	,    in_channels=4	,    down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')	,    cross_attention_dim=32	,    conditioning_embedding_out_channels=(16, 32)	,    )
          controlneta.controlnet_down_blocks.apply(snake_case			)

          torch.manual_seed(0			)
          __UpperCamelCase											=  ControlNetModel(
              block_out_channels=(32, 64)	,    layers_per_block=2	,    in_channels=4	,    down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')	,    cross_attention_dim=32	,    conditioning_embedding_out_channels=(16, 32)	,    )
          controlneta.controlnet_down_blocks.apply(snake_case			)

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

          __UpperCamelCase											=  MultiControlNetModel([controlneta, controlneta]			)

          __UpperCamelCase											=  {
              '''unet''': unet,
              '''controlnet''': controlnet,
              '''scheduler''': scheduler,
              '''vae''': vae,
              '''text_encoder''': text_encoder,
              '''tokenizer''': tokenizer,
              '''safety_checker''': None,
              '''feature_extractor''': None,
          }
          return components







      def  snake_case		(       self   :	Optional[int]	,    snake_case   :	Any	,    snake_case   :	Any=0			):
          if str(snake_case			).startswith('''mps'''			):
              __UpperCamelCase											=  torch.manual_seed(snake_case			)
          else:
              __UpperCamelCase											=  torch.Generator(device=snake_case			).manual_seed(snake_case			)

          __UpperCamelCase											=  2

          __UpperCamelCase											=  [
              randn_tensor(
                  (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)	,    generator=snake_case	,    device=torch.device(snake_case			)	,    ),
              randn_tensor(
                  (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)	,    generator=snake_case	,    device=torch.device(snake_case			)	,    ),
          ]
          __UpperCamelCase											=  floats_tensor((1, 3, 32, 32)	,    rng=random.Random(snake_case			)			).to(snake_case			)
          __UpperCamelCase											=  init_image.cpu().permute(0	,    2	,    3	,    1			)[0]

          __UpperCamelCase											=  Image.fromarray(np.uinta(snake_case			)			).convert('''RGB'''			).resize((64, 64)			)
          __UpperCamelCase											=  Image.fromarray(np.uinta(init_image + 4			)			).convert('''RGB'''			).resize((64, 64)			)

          __UpperCamelCase											=  {
              '''prompt''': '''A painting of a squirrel eating a burger''',
              '''generator''': generator,
              '''num_inference_steps''': 2,
              '''guidance_scale''': 6.0,
              '''output_type''': '''numpy''',
              '''image''': image,
              '''mask_image''': mask_image,
              '''control_image''': control_image,
          }

          return inputs







      def  snake_case		(       self   :	Tuple			):
          __UpperCamelCase											=  self.get_dummy_components()
          __UpperCamelCase											=  self.pipeline_class(**snake_case			)
          pipe.to(snake_case			)

          __UpperCamelCase											=  10.0
          __UpperCamelCase											=  4

          __UpperCamelCase											=  self.get_dummy_inputs(snake_case			)
          __UpperCamelCase											=  steps
          __UpperCamelCase											=  scale
          __UpperCamelCase											=  pipe(**snake_case			)[0]

          __UpperCamelCase											=  self.get_dummy_inputs(snake_case			)
          __UpperCamelCase											=  steps
          __UpperCamelCase											=  scale
          __UpperCamelCase											=  pipe(**snake_case	,    control_guidance_start=0.1	,    control_guidance_end=0.2			)[0]

          __UpperCamelCase											=  self.get_dummy_inputs(snake_case			)
          __UpperCamelCase											=  steps
          __UpperCamelCase											=  scale
          __UpperCamelCase											=  pipe(**snake_case	,    control_guidance_start=[0.1, 0.3]	,    control_guidance_end=[0.2, 0.7]			)[0]

          __UpperCamelCase											=  self.get_dummy_inputs(snake_case			)
          __UpperCamelCase											=  steps
          __UpperCamelCase											=  scale
          __UpperCamelCase											=  pipe(**snake_case	,    control_guidance_start=0.4	,    control_guidance_end=[0.5, 0.8]			)[0]

          # make sure that all outputs are different
          assert np.sum(np.abs(output_a - output_a			)			) > 1E-3
          assert np.sum(np.abs(output_a - output_a			)			) > 1E-3
          assert np.sum(np.abs(output_a - output_a			)			) > 1E-3







      def  snake_case		(       self   :	int			):
          return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3			)







      @unittest.skipIf(
          torch_device != '''cuda''' or not is_xformers_available()	,    reason='''XFormers attention is only available with CUDA and `xformers` installed'''	,    )
      def  snake_case		(       self   :	Tuple			):
          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3			)







      def  snake_case		(       self   :	str			):
          self._test_inference_batch_single_identical(expected_max_diff=2E-3			)







      def  snake_case		(       self   :	List[Any]			):
          __UpperCamelCase											=  self.get_dummy_components()
          __UpperCamelCase											=  self.pipeline_class(**snake_case			)
          pipe.to(snake_case			)
          pipe.set_progress_bar_config(disable=snake_case			)
          with tempfile.TemporaryDirectory() as tmpdir:
              try:
                  # save_pretrained is not implemented for Multi-ControlNet
                  pipe.save_pretrained(snake_case			)
              except NotImplementedError:
                  pass







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

      """simple docstring"""

      def  snake_case		(       self   :	Any			):
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()







      def  snake_case		(       self   :	Optional[int]			):
          __UpperCamelCase											=  ControlNetModel.from_pretrained('''lllyasviel/sd-controlnet-canny'''			)

          __UpperCamelCase											=  StableDiffusionControlNetInpaintPipeline.from_pretrained(
              '''runwayml/stable-diffusion-inpainting'''	,    safety_checker=snake_case	,    controlnet=snake_case			)
          pipe.enable_model_cpu_offload()
          pipe.set_progress_bar_config(disable=snake_case			)

          __UpperCamelCase											=  torch.Generator(device='''cpu'''			).manual_seed(0			)
          __UpperCamelCase											=  load_image(
              '''https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png'''			).resize((512, 512)			)

          __UpperCamelCase											=  load_image(
              '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'''
              '''/stable_diffusion_inpaint/input_bench_mask.png'''			).resize((512, 512)			)

          __UpperCamelCase											=  '''pitch black hole'''

          __UpperCamelCase											=  load_image(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png'''			).resize((512, 512)			)

          __UpperCamelCase											=  pipe(
              snake_case	,    image=snake_case	,    mask_image=snake_case	,    control_image=snake_case	,    generator=snake_case	,    output_type='''np'''	,    num_inference_steps=3	,    )

          __UpperCamelCase											=  output.images[0]

          assert image.shape == (512, 512, 3)

          __UpperCamelCase											=  load_numpy(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/inpaint.npy'''			)

          assert np.abs(expected_image - image			).max() < 9E-2







      def  snake_case		(       self   :	Optional[int]			):
          __UpperCamelCase											=  ControlNetModel.from_pretrained('''lllyasviel/control_v11p_sd15_inpaint'''			)

          __UpperCamelCase											=  StableDiffusionControlNetInpaintPipeline.from_pretrained(
              '''runwayml/stable-diffusion-v1-5'''	,    safety_checker=snake_case	,    controlnet=snake_case			)
          __UpperCamelCase											=  DDIMScheduler.from_config(pipe.scheduler.config			)
          pipe.enable_model_cpu_offload()
          pipe.set_progress_bar_config(disable=snake_case			)

          __UpperCamelCase											=  torch.Generator(device='''cpu'''			).manual_seed(33			)

          __UpperCamelCase											=  load_image(
              '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png'''			)
          __UpperCamelCase											=  init_image.resize((512, 512)			)

          __UpperCamelCase											=  load_image(
              '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png'''			)
          __UpperCamelCase											=  mask_image.resize((512, 512)			)

          __UpperCamelCase											=  '''a handsome man with ray-ban sunglasses'''

          def make_inpaint_condition(snake_case   :	Optional[Any]	,    snake_case   :	List[str]			):
              __UpperCamelCase											=  np.array(image.convert('''RGB'''			)			).astype(np.floataa			) / 2_55.0
              __UpperCamelCase											=  np.array(image_mask.convert('''L'''			)			).astype(np.floataa			) / 2_55.0

              assert image.shape[0:1] == image_mask.shape[0:1], "image and image_mask must have the same image size"
              __UpperCamelCase											=  -1.0  # set as masked pixel
              __UpperCamelCase											=  np.expand_dims(snake_case	,    0			).transpose(0	,    3	,    1	,    2			)
              __UpperCamelCase											=  torch.from_numpy(snake_case			)
              return image

          __UpperCamelCase											=  make_inpaint_condition(snake_case	,    snake_case			)

          __UpperCamelCase											=  pipe(
              snake_case	,    image=snake_case	,    mask_image=snake_case	,    control_image=snake_case	,    guidance_scale=9.0	,    eta=1.0	,    generator=snake_case	,    num_inference_steps=20	,    output_type='''np'''	,    )
          __UpperCamelCase											=  output.images[0]

          assert image.shape == (512, 512, 3)

          __UpperCamelCase											=  load_numpy(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/boy_ray_ban.npy'''			)

          assert np.abs(expected_image - image			).max() < 9E-2












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






