
import unittest

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

from diffusers import KandinskyVaaPriorPipeline, 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 __snake_case						( _lowerCamelCase   ,      unittest.TestCase	):
    _a						:		str=							KandinskyVaaPriorPipeline
    _a						:		Optional[int]=							['prompt']
    _a						:		Optional[Any]=							['prompt', 'negative_prompt']
    _a						:		List[Any]=							[
        'num_images_per_prompt',
        'generator',
        'num_inference_steps',
        'latents',
        'negative_prompt',
        'guidance_scale',
        'output_type',
        'return_dict',
    ]
    _a						:		int=							False
    @property
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           return 32
    @property
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           return 32
    @property
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           return self.time_input_dim
    @property
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







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



           '''simple docstring'''







           return 100
    @property
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           lowercase				:	int			      = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )
           return tokenizer
    @property
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           torch.manual_seed(0 )
           lowercase				:	int			      = 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=1000						,)
           return CLIPTextModelWithProjection(__UpperCamelCase )
    @property
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           torch.manual_seed(0 )

           lowercase				:	Optional[int]			      = {
               """num_attention_heads""": 2,
               """attention_head_dim""": 12,
               """embedding_dim""": self.text_embedder_hidden_size,
               """num_layers""": 1,
           }

           lowercase				:	str			      = PriorTransformer(**__UpperCamelCase )
           # 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
           lowercase				:	Union[str, Any]			      = nn.Parameter(torch.ones(model.clip_std.shape ) )
           return model
    @property
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           torch.manual_seed(0 )
           lowercase				:	str			      = 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						,)

           lowercase				:	Any			      = CLIPVisionModelWithProjection(__UpperCamelCase )
           return model
    @property
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           lowercase				:	int			      = CLIPImageProcessor(
               crop_size=224						,do_center_crop=__UpperCamelCase						,do_normalize=__UpperCamelCase						,do_resize=__UpperCamelCase						,image_mean=[0.48_145_466, 0.4_578_275, 0.40_821_073]						,image_std=[0.26_862_954, 0.26_130_258, 0.27_577_711]						,resample=3						,size=224						,)

           return image_processor
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           lowercase				:	Any			      = self.dummy_prior
           lowercase				:	Dict			      = self.dummy_image_encoder
           lowercase				:	Optional[int]			      = self.dummy_text_encoder
           lowercase				:	Any			      = self.dummy_tokenizer
           lowercase				:	Tuple			      = self.dummy_image_processor

           lowercase				:	List[Any]			      = UnCLIPScheduler(
               variance_type="""fixed_small_log"""						,prediction_type="""sample"""						,num_train_timesteps=1000						,clip_sample=__UpperCamelCase						,clip_sample_range=10.0						,)

           lowercase				:	int			      = {
               """prior""": prior,
               """image_encoder""": image_encoder,
               """text_encoder""": text_encoder,
               """tokenizer""": tokenizer,
               """scheduler""": scheduler,
               """image_processor""": image_processor,
           }

           return components
    def  _SCREAMING_SNAKE_CASE			(    self						,snake_case						,snake_case=0 ):



           '''simple docstring'''







           if str(__UpperCamelCase ).startswith("""mps""" ):
                  lowercase				:	str			      = torch.manual_seed(__UpperCamelCase )
           else:
                  lowercase				:	Optional[int]			      = torch.Generator(device=__UpperCamelCase ).manual_seed(__UpperCamelCase )
           lowercase				:	Optional[Any]			      = {
               """prompt""": """horse""",
               """generator""": generator,
               """guidance_scale""": 4.0,
               """num_inference_steps""": 2,
               """output_type""": """np""",
           }
           return inputs
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           lowercase				:	Tuple			      = """cpu"""

           lowercase				:	int			      = self.get_dummy_components()

           lowercase				:	List[Any]			      = self.pipeline_class(**__UpperCamelCase )
           lowercase				:	Any			      = pipe.to(__UpperCamelCase )

           pipe.set_progress_bar_config(disable=__UpperCamelCase )

           lowercase				:	Union[str, Any]			      = pipe(**self.get_dummy_inputs(__UpperCamelCase ) )
           lowercase				:	Any			      = output.image_embeds

           lowercase				:	Dict			      = pipe(
               **self.get_dummy_inputs(__UpperCamelCase )						,return_dict=__UpperCamelCase						,)[0]

           lowercase				:	Optional[int]			      = image[0, -10:]
           lowercase				:	List[str]			      = image_from_tuple[0, -10:]

           assert image.shape == (1, 32)

           lowercase				:	Tuple			      = np.array(
               [-0.0_532, 1.7_120, 0.3_656, -1.0_852, -0.8_946, -1.1_756, 0.4_348, 0.2_482, 0.5_146, -0.1_156] )

           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  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           lowercase				:	List[str]			      = torch_device == """cpu"""
           lowercase				:	Union[str, Any]			      = True
           lowercase				:	List[str]			      = False

           self._test_inference_batch_single_identical(
               test_max_difference=__UpperCamelCase						,relax_max_difference=__UpperCamelCase						,test_mean_pixel_difference=__UpperCamelCase						,)
    @skip_mps
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           lowercase				:	Dict			      = torch_device == """cpu"""
           lowercase				:	Optional[int]			      = False

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





from ...configuration_utils import PretrainedConfig
from ...utils import logging


__snake_case     :Optional[Any]			       =logging.get_logger(__name__)

__snake_case     :Tuple			       ={
    'transfo-xl-wt103': 'https://huggingface.co/transfo-xl-wt103/resolve/main/config.json',
}



class        lowerCAmelCase__					(  _lowerCamelCase       ):
				A_   :     Any								=     'transfo-xl'
				A_   :     Dict								=     ['mems']
				A_   :     int								=     {
				    'n_token': 'vocab_size',
				    'hidden_size': 'd_model',
				    'num_attention_heads': 'n_head',
				    'num_hidden_layers': 'n_layer',
				}


				def __init__(							self      :  Optional[Any]						, __UpperCamelCase      :  str=267_735						, __UpperCamelCase      :  int=[20_000, 40_000, 200_000]						, __UpperCamelCase      :  List[str]=1_024						, __UpperCamelCase      :  Union[str, Any]=1_024						, __UpperCamelCase      :  Optional[Any]=16						, __UpperCamelCase      :  Dict=64						, __UpperCamelCase      :  Optional[Any]=4_096						, __UpperCamelCase      :  int=4						, __UpperCamelCase      :  List[str]=False						, __UpperCamelCase      :  Optional[int]=18						, __UpperCamelCase      :  int=1_600						, __UpperCamelCase      :  Dict=1_000						, __UpperCamelCase      :  Optional[Any]=True						, __UpperCamelCase      :  Optional[Any]=True						, __UpperCamelCase      :  Optional[Any]=0						, __UpperCamelCase      :  Any=-1						, __UpperCamelCase      :  Any=True						, __UpperCamelCase      :  List[Any]=0.1						, __UpperCamelCase      :  str=0.0						, __UpperCamelCase      :  Dict=True						, __UpperCamelCase      :  int="normal"						, __UpperCamelCase      :  List[Any]=0.0_1						, __UpperCamelCase      :  str=0.0_1						, __UpperCamelCase      :  Any=0.0_2						, __UpperCamelCase      :  str=1e-5						, __UpperCamelCase      :  Optional[int]=0						, **__UpperCamelCase      :  Any						, )		->     int:
											A      						=    vocab_size
											A      						=    []
											self.cutoffs.extend(__UpperCamelCase       )
											if proj_share_all_but_first:
																		A      						=    [False] + [True] * len(self.cutoffs       )
											else:
																		A      						=    [False] + [False] * len(self.cutoffs       )
											A      						=    d_model
											A      						=    d_embed
											A      						=    d_head
											A      						=    d_inner
											A      						=    div_val
											A      						=    pre_lnorm
											A      						=    n_layer
											A      						=    n_head
											A      						=    mem_len
											A      						=    same_length
											A      						=    attn_type
											A      						=    clamp_len
											A      						=    sample_softmax
											A      						=    adaptive
											A      						=    dropout
											A      						=    dropatt
											A      						=    untie_r
											A      						=    init
											A      						=    init_range
											A      						=    proj_init_std
											A      						=    init_std
											A      						=    layer_norm_epsilon
											super().__init__(eos_token_id=__UpperCamelCase						, **__UpperCamelCase       )


				@property
				def __UpperCamelCase						(							self      :  Any       )		->     Optional[int]:
											# Message copied from Transformer-XL documentation
											logger.info(f'''The model {self.model_type} is one of the few models that has no sequence length limit.'''       )
											return -1


				@max_position_embeddings.setter
				def __UpperCamelCase						(							self      :  List[Any]						, __UpperCamelCase      :  List[Any]       )		->     List[Any]:
											# Message copied from Transformer-XL documentation
											raise NotImplementedError(
											    f'''The model {self.model_type} is one of the few models that has no sequence length limit.'''       )