


import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






class _lowerCamelCase(						_a, _a, unittest.TestCase   ):
       lowercase_ :	Dict     =			StableDiffusionSAGPipeline
       lowercase_ :	List[Any]     =			TEXT_TO_IMAGE_PARAMS
       lowercase_ :	List[Any]     =			TEXT_TO_IMAGE_BATCH_PARAMS
       lowercase_ :	Any     =			TEXT_TO_IMAGE_IMAGE_PARAMS
       lowercase_ :	Optional[Any]     =			TEXT_TO_IMAGE_IMAGE_PARAMS
       lowercase_ :	List[str]     =			False
       def 			UpperCamelCase     (					self)       ->   Dict:




           """simple docstring"""

           torch.manual_seed(0)
           _lowercase       :							int      		=		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,      )
           _lowercase       :							Tuple      		=		DDIMScheduler(
               beta_start=0.0_0_0_8_5,      beta_end=0.0_1_2,      beta_schedule='scaled_linear',      clip_sample=lowerCamelCase,      set_alpha_to_one=lowerCamelCase,      )
           torch.manual_seed(0)
           _lowercase       :							str      		=		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)
           _lowercase       :							List[str]      		=		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=10_00,      )
           _lowercase       :							Dict      		=		CLIPTextModel(lowerCamelCase)
           _lowercase       :							Optional[int]      		=		CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

           _lowercase       :							Optional[Any]      		=		{
               'unet': unet,
               'scheduler': scheduler,
               'vae': vae,
               'text_encoder': text_encoder,
               'tokenizer': tokenizer,
               'safety_checker': None,
               'feature_extractor': None,
           }
           return components
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase=0)       ->   Dict:




           """simple docstring"""

           if str(lowerCamelCase).startswith('mps'):
               _lowercase       :							str      		=		torch.manual_seed(lowerCamelCase)
           else:
               _lowercase       :							List[Any]      		=		torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase)
           _lowercase       :							List[Any]      		=		{
               'prompt': '.',
               'generator': generator,
               'num_inference_steps': 2,
               'guidance_scale': 1.0,
               'sag_scale': 1.0,
               'output_type': 'numpy',
           }
           return inputs




       def 			UpperCamelCase     (					self)       ->   List[str]:




           """simple docstring"""

           super().test_inference_batch_single_identical(expected_max_diff=3E-3)






@slow
@require_torch_gpu
class _lowerCamelCase(						unittest.TestCase   ):
       def 			UpperCamelCase     (					self)       ->   Dict:




           """simple docstring"""

           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()
       def 			UpperCamelCase     (					self)       ->   Optional[int]:




           """simple docstring"""

           _lowercase       :							Dict      		=		StableDiffusionSAGPipeline.from_pretrained('CompVis/stable-diffusion-v1-4')
           _lowercase       :							Optional[Any]      		=		sag_pipe.to(lowerCamelCase)
           sag_pipe.set_progress_bar_config(disable=lowerCamelCase)

           _lowercase       :							Tuple      		=		'.'
           _lowercase       :							int      		=		torch.manual_seed(0)
           _lowercase       :							Optional[Any]      		=		sag_pipe(
               [prompt],      generator=lowerCamelCase,      guidance_scale=7.5,      sag_scale=1.0,      num_inference_steps=20,      output_type='np')

           _lowercase       :							Tuple      		=		output.images

           _lowercase       :							Union[str, Any]      		=		image[0, -3:, -3:, -1]

           assert image.shape == (1, 5_12, 5_12, 3)
           _lowercase       :							Tuple      		=		np.array([0.1_5_6_8, 0.1_7_3_8, 0.1_6_9_5, 0.1_6_9_3, 0.1_5_0_7, 0.1_7_0_5, 0.1_5_4_7, 0.1_7_5_1, 0.1_9_4_9])

           assert np.abs(image_slice.flatten() - expected_slice).max() < 5E-2
       def 			UpperCamelCase     (					self)       ->   Union[str, Any]:




           """simple docstring"""

           _lowercase       :							List[Any]      		=		StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base')
           _lowercase       :							Dict      		=		sag_pipe.to(lowerCamelCase)
           sag_pipe.set_progress_bar_config(disable=lowerCamelCase)

           _lowercase       :							Union[str, Any]      		=		'.'
           _lowercase       :							str      		=		torch.manual_seed(0)
           _lowercase       :							Any      		=		sag_pipe(
               [prompt],      generator=lowerCamelCase,      guidance_scale=7.5,      sag_scale=1.0,      num_inference_steps=20,      output_type='np')

           _lowercase       :							List[str]      		=		output.images

           _lowercase       :							List[str]      		=		image[0, -3:, -3:, -1]

           assert image.shape == (1, 5_12, 5_12, 3)
           _lowercase       :							int      		=		np.array([0.3_4_5_9, 0.2_8_7_6, 0.2_5_3_7, 0.3_0_0_2, 0.2_6_7_1, 0.2_1_6_0, 0.3_0_2_6, 0.2_2_6_2, 0.2_3_7_1])

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




       def 			UpperCamelCase     (					self)       ->   Dict:




           """simple docstring"""

           _lowercase       :							Optional[Any]      		=		StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base')
           _lowercase       :							List[str]      		=		sag_pipe.to(lowerCamelCase)
           sag_pipe.set_progress_bar_config(disable=lowerCamelCase)

           _lowercase       :							Union[str, Any]      		=		'.'
           _lowercase       :							Tuple      		=		torch.manual_seed(0)
           _lowercase       :							List[Any]      		=		sag_pipe(
               [prompt],      width=7_68,      height=5_12,      generator=lowerCamelCase,      guidance_scale=7.5,      sag_scale=1.0,      num_inference_steps=20,      output_type='np',      )

           _lowercase       :							Tuple      		=		output.images

           assert image.shape == (1, 5_12, 7_68, 3)






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_speech_available,
    is_tf_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE       :      List[str]												= {
    "configuration_speech_to_text": ["SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Speech2TextConfig"],
    "processing_speech_to_text": ["Speech2TextProcessor"],
}

try:
 if not is_sentencepiece_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE       :      Union[str, Any]												= ["Speech2TextTokenizer"]

try:
 if not is_speech_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE       :      int												= ["Speech2TextFeatureExtractor"]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE       :      Optional[Any]												= [
     "TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST",
     "TFSpeech2TextForConditionalGeneration",
     "TFSpeech2TextModel",
     "TFSpeech2TextPreTrainedModel",
 ]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE       :      str												= [
     "SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST",
     "Speech2TextForConditionalGeneration",
     "Speech2TextModel",
     "Speech2TextPreTrainedModel",
 ]


if TYPE_CHECKING:
 from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig
 from .processing_speech_to_text import SpeechaTextProcessor

 try:
  if not is_sentencepiece_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_speech_to_text import SpeechaTextTokenizer

 try:
  if not is_speech_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_speech_to_text import (
      TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFSpeechaTextForConditionalGeneration,
      TFSpeechaTextModel,
      TFSpeechaTextPreTrainedModel,
  )

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_speech_to_text import (
      SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
      SpeechaTextForConditionalGeneration,
      SpeechaTextModel,
      SpeechaTextPreTrainedModel,
  )

else:
 import sys

 SCREAMING_SNAKE_CASE       :      Optional[Any]												= _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


