
"""simple docstring"""


import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin
from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
from .tokenization_wavaveca import WavaVecaCTCTokenizer



class 	__a	(   _lowerCAmelCase						):
       UpperCamelCase_		:       Optional[int]				=      '''Wav2Vec2FeatureExtractor'''
       UpperCamelCase_		:       int				=      '''AutoTokenizer'''






       def __init__(	self			:				Any							,   UpperCAmelCase_			:				int							,   UpperCAmelCase_			:				int      )->	int:







              """simple docstring"""
              super().__init__(lowercase__							,   lowercase__      )
              UpperCamelCase       			=		self.feature_extractor
              UpperCamelCase       			=		False






       @classmethod
       def 						_SCREAMING_SNAKE_CASE							(	cls			:				List[Any]							,   UpperCAmelCase_			:				List[Any]							,   **UpperCAmelCase_			:				str      )->	Any:







              """simple docstring"""



              try:
                     return super().from_pretrained(lowercase__							,   **lowercase__      )
              except OSError:
                     warnings.warn(
                         f"Loading a tokenizer inside {cls.__name__} from a config that does not"
                         " include a `tokenizer_class` attribute is deprecated and will be "
                         "removed in v5. Please add `\'tokenizer_class\': \'Wav2Vec2CTCTokenizer\'`"
                         " attribute to either your `config.json` or `tokenizer_config.json` "
                         "file to suppress this warning: "							,   lowercase__							,   )

                     UpperCamelCase       			=		WavaVecaFeatureExtractor.from_pretrained(lowercase__							,   **lowercase__      )
                     UpperCamelCase       			=		WavaVecaCTCTokenizer.from_pretrained(lowercase__							,   **lowercase__      )

                     return cls(feature_extractor=lowercase__							,   tokenizer=lowercase__      )






       def __call__(	self			:				List[Any]							,   *UpperCAmelCase_			:				Tuple							,   **UpperCAmelCase_			:				Tuple      )->	Optional[Any]:







              """simple docstring"""



              if self._in_target_context_manager:
                     return self.current_processor(*lowercase__							,   **lowercase__      )

              if "raw_speech" in kwargs:
                     warnings.warn("Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead."      )
                     UpperCamelCase       			=		kwargs.pop("raw_speech"      )
              else:
                     UpperCamelCase       			=		kwargs.pop("audio"							,   lowercase__      )
              UpperCamelCase       			=		kwargs.pop("sampling_rate"							,   lowercase__      )
              UpperCamelCase       			=		kwargs.pop("text"							,   lowercase__      )
              if len(lowercase__      ) > 0:
                     UpperCamelCase       			=		args[0]
                     UpperCamelCase       			=		args[1:]

              if audio is None and text is None:
                     raise ValueError("You need to specify either an `audio` or `text` input to process."      )

              if audio is not None:
                     UpperCamelCase       			=		self.feature_extractor(lowercase__							,   *lowercase__							,   sampling_rate=lowercase__							,   **lowercase__      )
              if text is not None:
                     UpperCamelCase       			=		self.tokenizer(lowercase__							,   **lowercase__      )

              if text is None:
                     return inputs
              elif audio is None:
                     return encodings
              else:
                     UpperCamelCase       			=		encodings["input_ids"]
                     return inputs






       def 						_SCREAMING_SNAKE_CASE							(	self			:				List[Any]							,   *UpperCAmelCase_			:				int							,   **UpperCAmelCase_			:				List[Any]      )->	int:







              """simple docstring"""



              if self._in_target_context_manager:
                     return self.current_processor.pad(*lowercase__							,   **lowercase__      )

              UpperCamelCase       			=		kwargs.pop("input_features"							,   lowercase__      )
              UpperCamelCase       			=		kwargs.pop("labels"							,   lowercase__      )
              if len(lowercase__      ) > 0:
                     UpperCamelCase       			=		args[0]
                     UpperCamelCase       			=		args[1:]

              if input_features is not None:
                     UpperCamelCase       			=		self.feature_extractor.pad(lowercase__							,   *lowercase__							,   **lowercase__      )
              if labels is not None:
                     UpperCamelCase       			=		self.tokenizer.pad(lowercase__							,   **lowercase__      )

              if labels is None:
                     return input_features
              elif input_features is None:
                     return labels
              else:
                     UpperCamelCase       			=		labels["input_ids"]
                     return input_features






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Any							,   *UpperCAmelCase_			:				int							,   **UpperCAmelCase_			:				str      )->	List[str]:







              """simple docstring"""
              return self.tokenizer.batch_decode(*lowercase__							,   **lowercase__      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Dict							,   *UpperCAmelCase_			:				Optional[Any]							,   **UpperCAmelCase_			:				str      )->	Tuple:







              """simple docstring"""
              return self.tokenizer.decode(*lowercase__							,   **lowercase__      )






       @contextmanager
       def 						_SCREAMING_SNAKE_CASE							(	self			:				str      )->	Any:







              """simple docstring"""
              warnings.warn(
                  "`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your "
                  "labels by using the argument `text` of the regular `__call__` method (either in the same call as "
                  "your audio inputs, or in a separate call."      )
              UpperCamelCase       			=		True
              UpperCamelCase       			=		self.tokenizer
              yield
              UpperCamelCase       			=		self.feature_extractor
              UpperCamelCase       			=		False








import gc
import unittest

import numpy as np
import torch

from diffusers import StableDiffusionKDiffusionPipeline
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()





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



       '''simple docstring'''







       def     __UpperCamelCase     (							self     ):







             '''simple docstring'''



             super().tearDown()
             gc.collect()
             torch.cuda.empty_cache()

       def     __UpperCamelCase     (							self     ):







             '''simple docstring'''



             __A    =StableDiffusionKDiffusionPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''     )
             __A    =sd_pipe.to(lowercase__     )
             sd_pipe.set_progress_bar_config(disable=lowercase__     )

             sd_pipe.set_scheduler('''sample_euler'''     )

             __A    ='''A painting of a squirrel eating a burger'''
             __A    =torch.manual_seed(0     )
             __A    =sd_pipe([prompt] ,   generator=lowercase__ ,   guidance_scale=9.0 ,   num_inference_steps=2_0 ,   output_type='''np'''     )

             __A    =output.images

             __A    =image[0, -3:, -3:, -1]

             assert image.shape == (1, 5_1_2, 5_1_2, 3)
             __A    =np.array([0.0447, 0.0492, 0.0468, 0.0408, 0.0383, 0.0408, 0.0354, 0.0380, 0.0339]     )

             assert np.abs(image_slice.flatten() - expected_slice     ).max() < 1E-2

       def     __UpperCamelCase     (							self     ):







             '''simple docstring'''



             __A    =StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''     )
             __A    =sd_pipe.to(lowercase__     )
             sd_pipe.set_progress_bar_config(disable=lowercase__     )

             sd_pipe.set_scheduler('''sample_euler'''     )

             __A    ='''A painting of a squirrel eating a burger'''
             __A    =torch.manual_seed(0     )
             __A    =sd_pipe([prompt] ,   generator=lowercase__ ,   guidance_scale=9.0 ,   num_inference_steps=2_0 ,   output_type='''np'''     )

             __A    =output.images

             __A    =image[0, -3:, -3:, -1]

             assert image.shape == (1, 5_1_2, 5_1_2, 3)
             __A    =np.array([0.1237, 0.1320, 0.1438, 0.1359, 0.1390, 0.1132, 0.1277, 0.1175, 0.1112]     )

             assert np.abs(image_slice.flatten() - expected_slice     ).max() < 5E-1


       def     __UpperCamelCase     (							self     ):







             '''simple docstring'''



             __A    =StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''     )
             __A    =sd_pipe.to(lowercase__     )
             sd_pipe.set_progress_bar_config(disable=lowercase__     )

             sd_pipe.set_scheduler('''sample_dpmpp_2m'''     )

             __A    ='''A painting of a squirrel eating a burger'''
             __A    =torch.manual_seed(0     )
             __A    =sd_pipe(
                 [prompt] ,   generator=lowercase__ ,   guidance_scale=7.5 ,   num_inference_steps=1_5 ,   output_type='''np''' ,   use_karras_sigmas=lowercase__ ,   )

             __A    =output.images

             __A    =image[0, -3:, -3:, -1]

             assert image.shape == (1, 5_1_2, 5_1_2, 3)
             __A    =np.array(
                 [0.1138_1689, 0.1211_2921, 0.138_9457, 0.1254_9606, 0.124_4964, 0.1083_1517, 0.1156_2866, 0.1086_7816, 0.1049_9048]     )

             assert np.abs(image_slice.flatten() - expected_slice     ).max() < 1E-2


