





import itertools
import os
import random
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers import is_speech_available
from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
       from transformers import WhisperFeatureExtractor

if is_torch_available():
       import torch

a__:      Optional[Any]									=		random.Random()


def 	UpperCamelCase__(       UpperCamelCase__			:       Tuple ,     UpperCamelCase__			:       Optional[Any]=1.0 ,     UpperCamelCase__			:       Union[str, Any]=None ,     UpperCamelCase__			:       Dict=None  )->Optional[int]:
       if rng is None:
              A__											=						global_rng

       A__											=						[]
       for batch_idx in range(shape[0]  ):
              values.append([]  )
              for _ in range(shape[1]  ):
                     values[-1].append(rng.random() * scale  )

       return values




@require_torch
@require_torchaudio
class     SCREAMING_SNAKE_CASE__ (						unittest.TestCase      ):



 def __init__(							self,__lowerCamelCase,__lowerCamelCase=7,__lowerCamelCase=400,__lowerCamelCase=2000,__lowerCamelCase=10,__lowerCamelCase=160,__lowerCamelCase=8,__lowerCamelCase=0.0,__lowerCamelCase=4000,__lowerCamelCase=False,__lowerCamelCase=True,):
        A__											=						parent
        A__											=						batch_size
        A__											=						min_seq_length
        A__											=						max_seq_length
        A__											=						(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
        A__											=						padding_value
        A__											=						sampling_rate
        A__											=						return_attention_mask
        A__											=						do_normalize
        A__											=						feature_size
        A__											=						chunk_length
        A__											=						hop_length



 def 				UpperCamelCase			(							self ):
        return {
            "feature_size": self.feature_size,
            "hop_length": self.hop_length,
            "chunk_length": self.chunk_length,
            "padding_value": self.padding_value,
            "sampling_rate": self.sampling_rate,
            "return_attention_mask": self.return_attention_mask,
            "do_normalize": self.do_normalize,
        }




 def 				UpperCamelCase			(							self,__lowerCamelCase=False,__lowerCamelCase=False ):
        def _flatten(__lowerCamelCase ):
               return list(itertools.chain(*__lowerCamelCase ) )

        if equal_length:
               A__											=						[floats_list((self.max_seq_length, self.feature_size) ) for _ in range(self.batch_size )]
        else:
               # make sure that inputs increase in size
               A__											=						[
                   floats_list((x, self.feature_size) )
                   for x in range(self.min_seq_length,self.max_seq_length,self.seq_length_diff )
               ]
        if numpify:
               A__											=						[np.asarray(__lowerCamelCase ) for x in speech_inputs]
        return speech_inputs




@require_torch
@require_torchaudio
class     SCREAMING_SNAKE_CASE__ (						UpperCamelCase__				,					unittest.TestCase      ):
 __SCREAMING_SNAKE_CASE							       =	WhisperFeatureExtractor if is_speech_available() else None



 def 				UpperCamelCase			(							self ):
        A__											=						WhisperFeatureExtractionTester(self )



 def 				UpperCamelCase			(							self ):
        A__											=						self.feature_extraction_class(**self.feat_extract_dict )

        with tempfile.TemporaryDirectory() as tmpdirname:
               A__											=						feat_extract_first.save_pretrained(__lowerCamelCase )[0]
               check_json_file_has_correct_format(__lowerCamelCase )
               A__											=						self.feature_extraction_class.from_pretrained(__lowerCamelCase )

        A__											=						feat_extract_first.to_dict()
        A__											=						feat_extract_second.to_dict()
        A__											=						feat_extract_first.mel_filters
        A__											=						feat_extract_second.mel_filters
        self.assertTrue(np.allclose(__lowerCamelCase,__lowerCamelCase ) )
        self.assertEqual(__lowerCamelCase,__lowerCamelCase )



 def 				UpperCamelCase			(							self ):
        A__											=						self.feature_extraction_class(**self.feat_extract_dict )

        with tempfile.TemporaryDirectory() as tmpdirname:
               A__											=						os.path.join(__lowerCamelCase,'''feat_extract.json''' )
               feat_extract_first.to_json_file(__lowerCamelCase )
               A__											=						self.feature_extraction_class.from_json_file(__lowerCamelCase )

        A__											=						feat_extract_first.to_dict()
        A__											=						feat_extract_second.to_dict()
        A__											=						feat_extract_first.mel_filters
        A__											=						feat_extract_second.mel_filters
        self.assertTrue(np.allclose(__lowerCamelCase,__lowerCamelCase ) )
        self.assertEqual(__lowerCamelCase,__lowerCamelCase )



 def 				UpperCamelCase			(							self ):
        # Tests that all call wrap to encode_plus and batch_encode_plus
        A__											=						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
        # create three inputs of length 800, 1000, and 1200
        A__											=						[floats_list((1, x) )[0] for x in range(800,1400,200 )]
        A__											=						[np.asarray(__lowerCamelCase ) for speech_input in speech_inputs]

        # Test feature size
        A__											=						feature_extractor(__lowerCamelCase,padding='''max_length''',return_tensors='''np''' ).input_features
        self.assertTrue(input_features.ndim == 3 )
        self.assertTrue(input_features.shape[-1] == feature_extractor.nb_max_frames )
        self.assertTrue(input_features.shape[-2] == feature_extractor.feature_size )

        # Test not batched input
        A__											=						feature_extractor(speech_inputs[0],return_tensors='''np''' ).input_features
        A__											=						feature_extractor(np_speech_inputs[0],return_tensors='''np''' ).input_features
        self.assertTrue(np.allclose(__lowerCamelCase,__lowerCamelCase,atol=1E-3 ) )

        # Test batched
        A__											=						feature_extractor(__lowerCamelCase,return_tensors='''np''' ).input_features
        A__											=						feature_extractor(__lowerCamelCase,return_tensors='''np''' ).input_features
        for enc_seq_a, enc_seq_a in zip(__lowerCamelCase,__lowerCamelCase ):
               self.assertTrue(np.allclose(__lowerCamelCase,__lowerCamelCase,atol=1E-3 ) )

        # Test 2-D numpy arrays are batched.
        A__											=						[floats_list((1, x) )[0] for x in (800, 800, 800)]
        A__											=						np.asarray(__lowerCamelCase )
        A__											=						feature_extractor(__lowerCamelCase,return_tensors='''np''' ).input_features
        A__											=						feature_extractor(__lowerCamelCase,return_tensors='''np''' ).input_features
        for enc_seq_a, enc_seq_a in zip(__lowerCamelCase,__lowerCamelCase ):
               self.assertTrue(np.allclose(__lowerCamelCase,__lowerCamelCase,atol=1E-3 ) )

        # Test truncation required
        A__											=						[floats_list((1, x) )[0] for x in range(200,(feature_extractor.n_samples + 500),200 )]
        A__											=						[np.asarray(__lowerCamelCase ) for speech_input in speech_inputs]

        A__											=						[x[: feature_extractor.n_samples] for x in speech_inputs]
        A__											=						[np.asarray(__lowerCamelCase ) for speech_input in speech_inputs_truncated]

        A__											=						feature_extractor(__lowerCamelCase,return_tensors='''np''' ).input_features
        A__											=						feature_extractor(__lowerCamelCase,return_tensors='''np''' ).input_features
        for enc_seq_a, enc_seq_a in zip(__lowerCamelCase,__lowerCamelCase ):
               self.assertTrue(np.allclose(__lowerCamelCase,__lowerCamelCase,atol=1E-3 ) )



 def 				UpperCamelCase			(							self ):
        import torch

        A__											=						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
        A__											=						np.random.rand(100,32 ).astype(np.floataa )
        A__											=						np_speech_inputs.tolist()

        for inputs in [py_speech_inputs, np_speech_inputs]:
               A__											=						feature_extractor.pad([{'''input_features''': inputs}],return_tensors='''np''' )
               self.assertTrue(np_processed.input_features.dtype == np.floataa )
               A__											=						feature_extractor.pad([{'''input_features''': inputs}],return_tensors='''pt''' )
               self.assertTrue(pt_processed.input_features.dtype == torch.floataa )



 def 				UpperCamelCase			(							self,__lowerCamelCase ):
        A__											=						load_dataset('''hf-internal-testing/librispeech_asr_dummy''','''clean''',split='''validation''' )
        # automatic decoding with librispeech
        A__											=						ds.sort('''id''' ).select(range(__lowerCamelCase ) )[:num_samples]['''audio''']

        return [x["array"] for x in speech_samples]



 def 				UpperCamelCase			(							self ):
        # fmt: off
        A__											=						torch.tensor(
            [
                0.1193, -0.0946, -0.1098, -0.0196, 0.0225, -0.0690, -0.1736, 0.0951,
                0.0971, -0.0817, -0.0702, 0.0162, 0.0260, 0.0017, -0.0192, -0.1678,
                0.0709, -0.1867, -0.0655, -0.0274, -0.0234, -0.1884, -0.0516, -0.0554,
                -0.0274, -0.1425, -0.1423, 0.0837, 0.0377, -0.0854
            ] )
        # fmt: on

        A__											=						self._load_datasamples(1 )
        A__											=						WhisperFeatureExtractor()
        A__											=						feature_extractor(__lowerCamelCase,return_tensors='''pt''' ).input_features
        self.assertEqual(input_features.shape,(1, 80, 3000) )
        self.assertTrue(torch.allclose(input_features[0, 0, :30],__lowerCamelCase,atol=1E-4 ) )




 def 				UpperCamelCase			(							self ):
        A__											=						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
        A__											=						self._load_datasamples(1 )[0]
        A__											=						((audio - audio.min()) / (audio.max() - audio.min())) * 6_5535  # Rescale to [0, 65535] to show issue
        A__											=						feat_extract.zero_mean_unit_var_norm([audio],attention_mask=__lowerCamelCase )[0]

        self.assertTrue(np.all(np.mean(__lowerCamelCase ) < 1E-3 ) )
        self.assertTrue(np.all(np.abs(np.var(__lowerCamelCase ) - 1 ) < 1E-3 ) )












import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionTextToImagePipeline
from diffusers.utils.testing_utils import nightly, require_torch_gpu, torch_device


a__:      List[str]									=		False




class     SCREAMING_SNAKE_CASE__ (						unittest.TestCase      ):
 pass




@nightly
@require_torch_gpu
class     SCREAMING_SNAKE_CASE__ (						unittest.TestCase      ):



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



 def 				UpperCamelCase			(							self ):
        A__											=						VersatileDiffusionTextToImagePipeline.from_pretrained('''shi-labs/versatile-diffusion''' )
        # remove text_unet
        pipe.remove_unused_weights()
        pipe.to(__lowerCamelCase )
        pipe.set_progress_bar_config(disable=__lowerCamelCase )

        A__											=						'''A painting of a squirrel eating a burger '''
        A__											=						torch.manual_seed(0 )
        A__											=						pipe(
            prompt=__lowerCamelCase,generator=__lowerCamelCase,guidance_scale=7.5,num_inference_steps=2,output_type='''numpy''' ).images

        with tempfile.TemporaryDirectory() as tmpdirname:
               pipe.save_pretrained(__lowerCamelCase )
               A__											=						VersatileDiffusionTextToImagePipeline.from_pretrained(__lowerCamelCase )
        pipe.to(__lowerCamelCase )
        pipe.set_progress_bar_config(disable=__lowerCamelCase )

        A__											=						generator.manual_seed(0 )
        A__											=						pipe(
            prompt=__lowerCamelCase,generator=__lowerCamelCase,guidance_scale=7.5,num_inference_steps=2,output_type='''numpy''' ).images

        assert np.abs(image - new_image ).sum() < 1E-5, "Models don't have the same forward pass"




 def 				UpperCamelCase			(							self ):
        A__											=						VersatileDiffusionTextToImagePipeline.from_pretrained(
            '''shi-labs/versatile-diffusion''',torch_dtype=torch.floataa )
        pipe.to(__lowerCamelCase )
        pipe.set_progress_bar_config(disable=__lowerCamelCase )

        A__											=						'''A painting of a squirrel eating a burger '''
        A__											=						torch.manual_seed(0 )
        A__											=						pipe(
            prompt=__lowerCamelCase,generator=__lowerCamelCase,guidance_scale=7.5,num_inference_steps=50,output_type='''numpy''' ).images

        A__											=						image[0, 253:256, 253:256, -1]

        assert image.shape == (1, 512, 512, 3)
        A__											=						np.array([0.3367, 0.3169, 0.2656, 0.3870, 0.4790, 0.3796, 0.4009, 0.4878, 0.4778] )

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





