


"""simple docstring"""





from typing import List

import datasets
from datasets.tasks import AudioClassification

from ..folder_based_builder import folder_based_builder


snake_case__						:   Dict			 = datasets.utils.logging.get_logger(__name__)



class 						snake_case_(				folder_based_builder.FolderBasedBuilderConfig	):
     __UpperCamelCase     =    None
     __UpperCamelCase     =    None



class 						snake_case_(				folder_based_builder.FolderBasedBuilder	):
     __UpperCamelCase     =    datasets.Audio()
     __UpperCamelCase     =    '''audio'''
     __UpperCamelCase     =    AudioFolderConfig
     __UpperCamelCase     =    42  # definition at the bottom of the script
     __UpperCamelCase     =    AudioClassification(audio_column='''audio'''							,    label_column='''label'''	)



snake_case__						:   Dict			 = [
    '''.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''',
]
snake_case__						:   List[Any]			 = AUDIO_EXTENSIONS






"""simple docstring"""





import gc
import unittest

from diffusers import FlaxDPMSolverMultistepScheduler, FlaxStableDiffusionPipeline
from diffusers.utils import is_flax_available, slow
from diffusers.utils.testing_utils import require_flax


if is_flax_available():
 import jax
 import jax.numpy as jnp
 from flax.jax_utils import replicate
 from flax.training.common_utils import shard



@slow
@require_flax
class 						snake_case_(				unittest.TestCase	):






     def    lowerCamelCase__   (		self     :    int ):
           # clean up the VRAM after each test
           super().tearDown()
           gc.collect()






     def    lowerCamelCase__   (		self     :    Optional[Any] ):
           lowerCAmelCase,					lowerCAmelCase    :		Optional[int]				=      FlaxStableDiffusionPipeline.from_pretrained(
               '''stabilityai/stable-diffusion-2'''    , revision='''bf16'''    , dtype=jnp.bfloataa    , )

           lowerCAmelCase    :		Optional[int]				=      '''A painting of a squirrel eating a burger'''
           lowerCAmelCase    :		List[str]				=      jax.device_count()
           lowerCAmelCase    :		Optional[int]				=      num_samples * [prompt]
           lowerCAmelCase    :		Any				=      sd_pipe.prepare_inputs(UpperCamelCase_ )

           lowerCAmelCase    :		Optional[int]				=      replicate(UpperCamelCase_ )
           lowerCAmelCase    :		Union[str, Any]				=      shard(UpperCamelCase_ )

           lowerCAmelCase    :		Optional[int]				=      jax.random.PRNGKey(0 )
           lowerCAmelCase    :		Optional[Any]				=      jax.random.split(UpperCamelCase_    , jax.device_count() )

           lowerCAmelCase    :		str				=      sd_pipe(UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_    , num_inference_steps=2_5    , jit=UpperCamelCase_ )[0]
           assert images.shape == (jax.device_count(), 1, 7_6_8, 7_6_8, 3)

           lowerCAmelCase    :		str				=      images.reshape((images.shape[0] * images.shape[1],) + images.shape[-3:] )
           lowerCAmelCase    :		List[str]				=      images[0, 2_5_3:2_5_6, 2_5_3:2_5_6, -1]

           lowerCAmelCase    :		Dict				=      jnp.asarray(jax.device_get(image_slice.flatten() ) )
           lowerCAmelCase    :		List[str]				=      jnp.array([0.4_238, 0.4_414, 0.4_395, 0.4_453, 0.4_629, 0.4_590, 0.4_531, 0.45_508, 0.4_512] )
           print(F'''output_slice: {output_slice}''' )
           assert jnp.abs(output_slice - expected_slice ).max() < 1E-2






     def    lowerCamelCase__   (		self     :    Union[str, Any] ):
           lowerCAmelCase    :		Union[str, Any]				=      '''stabilityai/stable-diffusion-2'''
           lowerCAmelCase,					lowerCAmelCase    :		Dict				=      FlaxDPMSolverMultistepScheduler.from_pretrained(UpperCamelCase_    , subfolder='''scheduler''' )
           lowerCAmelCase,					lowerCAmelCase    :		int				=      FlaxStableDiffusionPipeline.from_pretrained(
               UpperCamelCase_    , scheduler=UpperCamelCase_    , revision='''bf16'''    , dtype=jnp.bfloataa    , )
           lowerCAmelCase    :		List[Any]				=      scheduler_params

           lowerCAmelCase    :		List[Any]				=      '''A painting of a squirrel eating a burger'''
           lowerCAmelCase    :		Any				=      jax.device_count()
           lowerCAmelCase    :		int				=      num_samples * [prompt]
           lowerCAmelCase    :		int				=      sd_pipe.prepare_inputs(UpperCamelCase_ )

           lowerCAmelCase    :		Dict				=      replicate(UpperCamelCase_ )
           lowerCAmelCase    :		Tuple				=      shard(UpperCamelCase_ )

           lowerCAmelCase    :		int				=      jax.random.PRNGKey(0 )
           lowerCAmelCase    :		Optional[int]				=      jax.random.split(UpperCamelCase_    , jax.device_count() )

           lowerCAmelCase    :		Tuple				=      sd_pipe(UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_    , num_inference_steps=2_5    , jit=UpperCamelCase_ )[0]
           assert images.shape == (jax.device_count(), 1, 7_6_8, 7_6_8, 3)

           lowerCAmelCase    :		Any				=      images.reshape((images.shape[0] * images.shape[1],) + images.shape[-3:] )
           lowerCAmelCase    :		str				=      images[0, 2_5_3:2_5_6, 2_5_3:2_5_6, -1]

           lowerCAmelCase    :		Optional[int]				=      jnp.asarray(jax.device_get(image_slice.flatten() ) )
           lowerCAmelCase    :		Tuple				=      jnp.array([0.4_336, 0.42_969, 0.4_453, 0.4_199, 0.4_297, 0.4_531, 0.4_434, 0.4_434, 0.4_297] )
           print(F'''output_slice: {output_slice}''' )
           assert jnp.abs(output_slice - expected_slice ).max() < 1E-2


