




'''simple docstring'''







import unittest

import numpy as np
import torch
from torch import nn
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import KandinskyPriorPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


class      _a    (      __a				,				unittest.TestCase					):
       __a							:	List[Any]  							=   KandinskyPriorPipeline
       __a							:	List[Any]  							=   ["""prompt"""]
       __a							:	int  							=   ["""prompt""", """negative_prompt"""]
       __a							:	List[Any]  							=   [
           """num_images_per_prompt""",
           """generator""",
           """num_inference_steps""",
           """latents""",
           """negative_prompt""",
           """guidance_scale""",
           """output_type""",
           """return_dict""",
       ]
       __a							:	str  							=   False
       @property
       def        A (      self		:      List[str]							):



           '''simple docstring'''

           return 32
       @property
       def        A (      self		:      Union[str, Any]							):



           '''simple docstring'''

           return 32
       @property
       def        A (      self		:      List[str]							):



           '''simple docstring'''

           return self.time_input_dim
       @property
       def        A (      self		:      Optional[int]							):



           '''simple docstring'''

           return self.time_input_dim * 4
       @property
       def        A (      self		:      int							):



           '''simple docstring'''

           return 100
       @property
       def        A (      self		:      Tuple							):



           '''simple docstring'''

           UpperCAmelCase     			=						CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''							)
           return tokenizer
       @property
       def        A (      self		:      Optional[int]							):



           '''simple docstring'''

           torch.manual_seed(0							)
           UpperCAmelCase     			=						CLIPTextConfig(
               bos_token_id=0  ,							eos_token_id=2  ,							hidden_size=self.text_embedder_hidden_size  ,							projection_dim=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=1_000  ,							)
           return CLIPTextModelWithProjection(lowercase							)
       @property
       def        A (      self		:      Optional[int]							):



           '''simple docstring'''

           torch.manual_seed(0							)

           UpperCAmelCase     			=						{
               '''num_attention_heads''': 2,
               '''attention_head_dim''': 12,
               '''embedding_dim''': self.text_embedder_hidden_size,
               '''num_layers''': 1,
           }

           UpperCAmelCase     			=						PriorTransformer(**lowercase							)
           # clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
           UpperCAmelCase     			=						nn.Parameter(torch.ones(model.clip_std.shape							)							)
           return model
       @property
       def        A (      self		:      str							):



           '''simple docstring'''

           torch.manual_seed(0							)
           UpperCAmelCase     			=						CLIPVisionConfig(
               hidden_size=self.text_embedder_hidden_size  ,							image_size=224  ,							projection_dim=self.text_embedder_hidden_size  ,							intermediate_size=37  ,							num_attention_heads=4  ,							num_channels=3  ,							num_hidden_layers=5  ,							patch_size=14  ,							)

           UpperCAmelCase     			=						CLIPVisionModelWithProjection(lowercase							)
           return model
       @property
       def        A (      self		:      int							):



           '''simple docstring'''

           UpperCAmelCase     			=						CLIPImageProcessor(
               crop_size=224  ,							do_center_crop=lowercase  ,							do_normalize=lowercase  ,							do_resize=lowercase  ,							image_mean=[0.4814_5466, 0.457_8275, 0.4082_1073]  ,							image_std=[0.2686_2954, 0.2613_0258, 0.2757_7711]  ,							resample=3  ,							size=224  ,							)

           return image_processor
       def        A (      self		:      Tuple							):



           '''simple docstring'''

           UpperCAmelCase     			=						self.dummy_prior
           UpperCAmelCase     			=						self.dummy_image_encoder
           UpperCAmelCase     			=						self.dummy_text_encoder
           UpperCAmelCase     			=						self.dummy_tokenizer
           UpperCAmelCase     			=						self.dummy_image_processor

           UpperCAmelCase     			=						UnCLIPScheduler(
               variance_type='''fixed_small_log'''  ,							prediction_type='''sample'''  ,							num_train_timesteps=1_000  ,							clip_sample=lowercase  ,							clip_sample_range=10.0  ,							)

           UpperCAmelCase     			=						{
               '''prior''': prior,
               '''image_encoder''': image_encoder,
               '''text_encoder''': text_encoder,
               '''tokenizer''': tokenizer,
               '''scheduler''': scheduler,
               '''image_processor''': image_processor,
           }

           return components
       def        A (      self		:      Union[str, Any]  ,							lowercase		:      Optional[int]  ,							lowercase		:      Any=0							):



           '''simple docstring'''

           if str(lowercase							).startswith('''mps'''							):
               UpperCAmelCase     			=						torch.manual_seed(lowercase							)
           else:
               UpperCAmelCase     			=						torch.Generator(device=lowercase							).manual_seed(lowercase							)
           UpperCAmelCase     			=						{
               '''prompt''': '''horse''',
               '''generator''': generator,
               '''guidance_scale''': 4.0,
               '''num_inference_steps''': 2,
               '''output_type''': '''np''',
           }
           return inputs
       def        A (      self		:      str							):



           '''simple docstring'''

           UpperCAmelCase     			=						'''cpu'''

           UpperCAmelCase     			=						self.get_dummy_components()

           UpperCAmelCase     			=						self.pipeline_class(**lowercase							)
           UpperCAmelCase     			=						pipe.to(lowercase							)

           pipe.set_progress_bar_config(disable=lowercase							)

           UpperCAmelCase     			=						pipe(**self.get_dummy_inputs(lowercase							)							)
           UpperCAmelCase     			=						output.image_embeds

           UpperCAmelCase     			=						pipe(
               **self.get_dummy_inputs(lowercase							)  ,							return_dict=lowercase  ,							)[0]

           UpperCAmelCase     			=						image[0, -10:]
           UpperCAmelCase     			=						image_from_tuple[0, -10:]

           assert image.shape == (1, 32)

           UpperCAmelCase     			=						np.array(
               [-0.0532, 1.7120, 0.3656, -1.0852, -0.8946, -1.1756, 0.4348, 0.2482, 0.5146, -0.1156]							)

           assert np.abs(image_slice.flatten() - expected_slice							).max() < 1E-2
           assert np.abs(image_from_tuple_slice.flatten() - expected_slice							).max() < 1E-2
       @skip_mps
       def        A (      self		:      Optional[Any]							):



           '''simple docstring'''

           UpperCAmelCase     			=						torch_device == '''cpu'''
           UpperCAmelCase     			=						True
           UpperCAmelCase     			=						False

           self._test_inference_batch_single_identical(
               test_max_difference=lowercase  ,							relax_max_difference=lowercase  ,							test_mean_pixel_difference=lowercase  ,							)







       @skip_mps
       def        A (      self		:      List[Any]							):



           '''simple docstring'''

           UpperCAmelCase     			=						torch_device == '''cpu'''
           UpperCAmelCase     			=						False

           self._test_attention_slicing_forward_pass(
               test_max_difference=lowercase  ,							test_mean_pixel_difference=lowercase  ,							)










'''simple docstring'''







from ..utils import DummyObject, requires_backends


class      _a    (      metaclass=__a					):
       __a							:	str  							=   ["""torch""", """librosa"""]
       def __init__(      self		:      int  ,							*lowercase		:      Any  ,							**lowercase		:      Optional[int]							):



           '''simple docstring'''

           requires_backends(self  ,							['''torch''', '''librosa''']							)
       @classmethod
       def        A (      cls		:      Optional[int]  ,							*lowercase		:      List[str]  ,							**lowercase		:      str							):



           '''simple docstring'''

           requires_backends(cls  ,							['''torch''', '''librosa''']							)







       @classmethod
       def        A (      cls		:      Dict  ,							*lowercase		:      Optional[int]  ,							**lowercase		:      List[Any]							):



           '''simple docstring'''

           requires_backends(cls  ,							['''torch''', '''librosa''']							)






class      _a    (      metaclass=__a					):
       __a							:	List[Any]  							=   ["""torch""", """librosa"""]
       def __init__(      self		:      int  ,							*lowercase		:      Optional[int]  ,							**lowercase		:      Optional[int]							):



           '''simple docstring'''

           requires_backends(self  ,							['''torch''', '''librosa''']							)
       @classmethod
       def        A (      cls		:      Dict  ,							*lowercase		:      Tuple  ,							**lowercase		:      List[str]							):



           '''simple docstring'''

           requires_backends(cls  ,							['''torch''', '''librosa''']							)







       @classmethod
       def        A (      cls		:      Any  ,							*lowercase		:      Any  ,							**lowercase		:      Tuple							):



           '''simple docstring'''

           requires_backends(cls  ,							['''torch''', '''librosa''']							)




