




'''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[str]           = KandinskyPriorPipeline
       __a    :					Union[str, Any]           = ["""prompt"""]
       __a    :					Union[str, 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    :					List[Any]           = False
       @property
       def      A				(     self						:     Optional[Any]    ):



           '''simple docstring'''

           return 32
       @property
       def      A				(     self						:     Optional[Any]    ):



           '''simple docstring'''

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



           '''simple docstring'''

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



           '''simple docstring'''

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



           '''simple docstring'''

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



           '''simple docstring'''

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



           '''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						:     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						:     List[Any]    ):



           '''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						:     Optional[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						:     List[Any]    ):



           '''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						:     Tuple       ,    lowercase						:     Dict       ,    lowercase						:     str=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						:     Any    ):



           '''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						:     List[str]    ):



           '''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[str]    ):



           '''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'''







import os
import tempfile
import unittest
from typing import List

from transformers.models.esm.tokenization_esm import VOCAB_FILES_NAMES, EsmTokenizer
from transformers.testing_utils import require_tokenizers
from transformers.tokenization_utils import PreTrainedTokenizer
from transformers.tokenization_utils_base import PreTrainedTokenizerBase


@require_tokenizers
class       _a  (     unittest.TestCase			):
       __a    :					Optional[int]           = EsmTokenizer
       def    A				(     self						:     Tuple    ):



           '''simple docstring'''

           super().setUp()
           UpperCAmelCase      	=		tempfile.mkdtemp()
           # fmt: off
           UpperCAmelCase      	=		["<cls>", "<pad>", "<eos>", "<unk>", "L", "A", "G", "V", "S", "E", "R", "T", "I", "D", "P", "K", "Q", "N", "F", "Y", "M", "H", "W", "C", "X", "B", "U", "Z", "O", ".", "-", "<null_1>", "<mask>"]  # noqa: E501
           # fmt: on
           UpperCAmelCase      	=		os.path.join(self.tmpdirname       ,    VOCAB_FILES_NAMES['''vocab_file''']    )
           with open(self.vocab_file       ,    '''w'''       ,    encoding='''utf-8'''    ) as vocab_writer:
               vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]    )    )
       def    A				(     self						:     Union[str, Any]       ,    **lowercase						:     Tuple    ):



           '''simple docstring'''

           return [self.get_tokenizer(**lowercase    )]
       def    A				(     self						:     Optional[Any]       ,    **lowercase						:     str    ):



           '''simple docstring'''

           return self.tokenizer_class.from_pretrained(self.tmpdirname       ,    **lowercase    )
       def    A				(     self						:     Optional[Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.tokenizer_class(self.vocab_file    )

           UpperCAmelCase      	=		tokenizer.tokenize('''LAGVS'''    )
           self.assertListEqual(lowercase       ,    ['''L''', '''A''', '''G''', '''V''', '''S''']    )
           self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase    )       ,    [4, 5, 6, 7, 8]    )
       def    A				(     self						:     str    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.tokenizer_class(self.vocab_file    )

           UpperCAmelCase      	=		'''LAGVS'''
           self.assertListEqual(tokenizer.encode(lowercase    )       ,    [0, 4, 5, 6, 7, 8, 2]    )
       def    A				(     self						:     Optional[Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.tokenizer_class(self.vocab_file    )

           UpperCAmelCase      	=		['''LAGVS''', '''WCB''']
           UpperCAmelCase      	=		tokenizer(lowercase       ,    padding=lowercase    )['''input_ids''']

           self.assertListEqual(lowercase       ,    [[0, 4, 5, 6, 7, 8, 2], [0, 22, 23, 25, 2]]    )
       def    A				(     self						:     Union[str, Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.tokenizer_class(self.vocab_file    )

           UpperCAmelCase      	=		['''LAGVS''', '''WCB''']
           UpperCAmelCase      	=		tokenizer(lowercase       ,    padding=lowercase    )['''input_ids''']

           self.assertListEqual(lowercase       ,    [[0, 4, 5, 6, 7, 8, 2], [0, 22, 23, 25, 2, 1, 1]]    )







       def    A				(     self						:     Any    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.get_tokenizers(fast=lowercase    )
           for tokenizer in tokenizers:
               with self.subTest(f"{tokenizer.__class__.__name__}"    ):
                   UpperCAmelCase      	=		'''<unk>'''
                   UpperCAmelCase      	=		'''<mask>'''

                   UpperCAmelCase      	=		tokenizer.tokenize(lowercase    )
                   UpperCAmelCase      	=		tokenizer.tokenize(lowercase    )

                   self.assertEqual(len(lowercase    )       ,    1    )
                   self.assertEqual(len(lowercase    )       ,    1    )
                   self.assertEqual(token_a[0]       ,    lowercase    )
                   self.assertEqual(token_a[0]       ,    lowercase    )




