

import gc
import unittest

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

from diffusers import TransformeraDModel, VQDiffusionPipeline, VQDiffusionScheduler, VQModel
from diffusers.pipelines.vq_diffusion.pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings
from diffusers.utils import load_numpy, slow, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


_SCREAMING_SNAKE_CASE  :						List[Any]         =    False






class  UpperCAmelCase__	( unittest.TestCase ):






  """simple docstring"""


  def    lowercase_	(							self		:	List[str]      )	->							Dict:
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()






  @property
  def    lowercase_	(							self		:	Dict      )	->							Optional[Any]:
       return 12






  @property
  def    lowercase_	(							self		:	List[str]      )	->							List[str]:
       return 12






  @property
  def    lowercase_	(							self		:	Dict      )	->							str:
       return 32






  @property
  def    lowercase_	(							self		:	Optional[Any]      )	->							Union[str, Any]:
       torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					VQModel(
           block_out_channels=[32, 64]			,     in_channels=3			,     out_channels=3			,     down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']			,     up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']			,     latent_channels=3			,     num_vq_embeddings=self.num_embed			,     vq_embed_dim=3			,     )
       return model






  @property
  def    lowercase_	(							self		:	List[str]      )	->							Optional[int]:
       SCREAMING_SNAKE_CASE__					=					CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )
       return tokenizer






  @property
  def    lowercase_	(							self		:	List[Any]      )	->							List[str]:
       torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					CLIPTextConfig(
           bos_token_id=0			,     eos_token_id=2			,     hidden_size=self.text_embedder_hidden_size			,     intermediate_size=37			,     layer_norm_eps=1e-05			,     num_attention_heads=4			,     num_hidden_layers=5			,     pad_token_id=1			,     vocab_size=1000			,     )
       return CLIPTextModel(__lowerCamelCase      )






  @property
  def    lowercase_	(							self		:	List[Any]      )	->							Optional[Any]:
       torch.manual_seed(0      )

       SCREAMING_SNAKE_CASE__					=					12
       SCREAMING_SNAKE_CASE__					=					12

       SCREAMING_SNAKE_CASE__					=					{
           '''attention_bias''': True,
           '''cross_attention_dim''': 32,
           '''attention_head_dim''': height * width,
           '''num_attention_heads''': 1,
           '''num_vector_embeds''': self.num_embed,
           '''num_embeds_ada_norm''': self.num_embeds_ada_norm,
           '''norm_num_groups''': 32,
           '''sample_size''': width,
           '''activation_fn''': '''geglu-approximate''',
       }

       SCREAMING_SNAKE_CASE__					=					TransformeraDModel(**__lowerCamelCase      )
       return model






  def    lowercase_	(							self		:	int      )	->							Dict:
       SCREAMING_SNAKE_CASE__					=					'''cpu'''

       SCREAMING_SNAKE_CASE__					=					self.dummy_vqvae
       SCREAMING_SNAKE_CASE__					=					self.dummy_text_encoder
       SCREAMING_SNAKE_CASE__					=					self.dummy_tokenizer
       SCREAMING_SNAKE_CASE__					=					self.dummy_transformer
       SCREAMING_SNAKE_CASE__					=					VQDiffusionScheduler(self.num_embed      )
       SCREAMING_SNAKE_CASE__					=					LearnedClassifierFreeSamplingEmbeddings(learnable=__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					VQDiffusionPipeline(
           vqvae=__lowerCamelCase			,     text_encoder=__lowerCamelCase			,     tokenizer=__lowerCamelCase			,     transformer=__lowerCamelCase			,     scheduler=__lowerCamelCase			,     learned_classifier_free_sampling_embeddings=__lowerCamelCase			,     )
       SCREAMING_SNAKE_CASE__					=					pipe.to(__lowerCamelCase      )
       pipe.set_progress_bar_config(disable=__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					'''teddy bear playing in the pool'''

       SCREAMING_SNAKE_CASE__					=					torch.Generator(device=__lowerCamelCase      ).manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					pipe([prompt]			,     generator=__lowerCamelCase			,     num_inference_steps=2			,     output_type='''np'''      )
       SCREAMING_SNAKE_CASE__					=					output.images

       SCREAMING_SNAKE_CASE__					=					torch.Generator(device=__lowerCamelCase      ).manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					pipe(
           [prompt]			,     generator=__lowerCamelCase			,     output_type='''np'''			,     return_dict=__lowerCamelCase			,     num_inference_steps=2      )[0]

       SCREAMING_SNAKE_CASE__					=					image[0, -3:, -3:, -1]
       SCREAMING_SNAKE_CASE__					=					image_from_tuple[0, -3:, -3:, -1]

       assert image.shape == (1, 24, 24, 3)

       SCREAMING_SNAKE_CASE__					=					np.array([0.6551, 0.6168, 0.5008, 0.5676, 0.5659, 0.4295, 0.6073, 0.5599, 0.4992]      )

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







  def    lowercase_	(							self		:	Optional[int]      )	->							List[str]:
       SCREAMING_SNAKE_CASE__					=					'''cpu'''

       SCREAMING_SNAKE_CASE__					=					self.dummy_vqvae
       SCREAMING_SNAKE_CASE__					=					self.dummy_text_encoder
       SCREAMING_SNAKE_CASE__					=					self.dummy_tokenizer
       SCREAMING_SNAKE_CASE__					=					self.dummy_transformer
       SCREAMING_SNAKE_CASE__					=					VQDiffusionScheduler(self.num_embed      )
       SCREAMING_SNAKE_CASE__					=					LearnedClassifierFreeSamplingEmbeddings(
           learnable=__lowerCamelCase			,     hidden_size=self.text_embedder_hidden_size			,     length=tokenizer.model_max_length      )

       SCREAMING_SNAKE_CASE__					=					VQDiffusionPipeline(
           vqvae=__lowerCamelCase			,     text_encoder=__lowerCamelCase			,     tokenizer=__lowerCamelCase			,     transformer=__lowerCamelCase			,     scheduler=__lowerCamelCase			,     learned_classifier_free_sampling_embeddings=__lowerCamelCase			,     )
       SCREAMING_SNAKE_CASE__					=					pipe.to(__lowerCamelCase      )
       pipe.set_progress_bar_config(disable=__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					'''teddy bear playing in the pool'''

       SCREAMING_SNAKE_CASE__					=					torch.Generator(device=__lowerCamelCase      ).manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					pipe([prompt]			,     generator=__lowerCamelCase			,     num_inference_steps=2			,     output_type='''np'''      )
       SCREAMING_SNAKE_CASE__					=					output.images

       SCREAMING_SNAKE_CASE__					=					torch.Generator(device=__lowerCamelCase      ).manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					pipe(
           [prompt]			,     generator=__lowerCamelCase			,     output_type='''np'''			,     return_dict=__lowerCamelCase			,     num_inference_steps=2      )[0]

       SCREAMING_SNAKE_CASE__					=					image[0, -3:, -3:, -1]
       SCREAMING_SNAKE_CASE__					=					image_from_tuple[0, -3:, -3:, -1]

       assert image.shape == (1, 24, 24, 3)

       SCREAMING_SNAKE_CASE__					=					np.array([0.6693, 0.6075, 0.4959, 0.5701, 0.5583, 0.4333, 0.6171, 0.5684, 0.4988]      )

       assert np.abs(image_slice.flatten() - expected_slice      ).max() < 2.0
       assert np.abs(image_from_tuple_slice.flatten() - expected_slice      ).max() < 1e-2






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






  """simple docstring"""


  def    lowercase_	(							self		:	Any      )	->							Any:
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()







  def    lowercase_	(							self		:	int      )	->							Optional[int]:
       SCREAMING_SNAKE_CASE__					=					load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
           '''/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy'''      )

       SCREAMING_SNAKE_CASE__					=					VQDiffusionPipeline.from_pretrained('''microsoft/vq-diffusion-ithq'''      )
       SCREAMING_SNAKE_CASE__					=					pipeline.to(__lowerCamelCase      )
       pipeline.set_progress_bar_config(disable=__lowerCamelCase      )

       # requires GPU generator for gumbel softmax
       # don't use GPU generator in tests though
       SCREAMING_SNAKE_CASE__					=					torch.Generator(device=__lowerCamelCase      ).manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					pipeline(
           '''teddy bear playing in the pool'''			,     num_images_per_prompt=1			,     generator=__lowerCamelCase			,     output_type='''np'''			,     )

       SCREAMING_SNAKE_CASE__					=					output.images[0]

       assert image.shape == (256, 256, 3)
       assert np.abs(expected_image - image      ).max() < 2.0





from typing import List

import datasets
from datasets.tasks import AudioClassification

from ..folder_based_builder import folder_based_builder


_SCREAMING_SNAKE_CASE  :						Optional[Any]         =    datasets.utils.logging.get_logger(__name__)






class  UpperCAmelCase__	( folder_based_builder.FolderBasedBuilderConfig ):






  """simple docstring"""


  a     =      None
  a     =      None






class  UpperCAmelCase__	( folder_based_builder.FolderBasedBuilder ):






  """simple docstring"""


  a     =      datasets.Audio()
  a     =      "audio"
  a     =      AudioFolderConfig
  a     =      42  # definition at the bottom of the script
  a     =      AudioClassification(audio_column="audio"		,  label_column="label" )



_SCREAMING_SNAKE_CASE  :						str         =    [
    '''.aiff''',
    '''.au''',
    '''.avr''',
    '''.caf''',
    '''.flac''',
    '''.htk''',
    '''.svx''',
    '''.mat4''',
    '''.mat5''',
    '''.mpc2k''',
    '''.ogg''',
    '''.paf''',
    '''.pvf''',
    '''.raw''',
    '''.rf64''',
    '''.sd2''',
    '''.sds''',
    '''.ircam''',
    '''.voc''',
    '''.w64''',
    '''.wav''',
    '''.nist''',
    '''.wavex''',
    '''.wve''',
    '''.xi''',
    '''.mp3''',
    '''.opus''',
]
_SCREAMING_SNAKE_CASE  :						List[Any]         =    AUDIO_EXTENSIONS


