'''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 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 		_lowerCamelCase		(   UpperCamelCase_    ,     unittest.TestCase    ):
    __a  =      KandinskyVaaPriorPipeline
    __a  =      ["prompt"]
    __a  =      ["prompt", "negative_prompt"]
    __a  =      [
        "num_images_per_prompt",
        "generator",
        "num_inference_steps",
        "latents",
        "negative_prompt",
        "guidance_scale",
        "output_type",
        "return_dict",
    ]
    __a  =      False
    @property
    def 						UpperCamelCase_				(  self   )       ->					Dict:
     return 32
    @property
    def 						UpperCamelCase_				(  self   )       ->					Any:
     return 32
    @property
    def 						UpperCamelCase_				(  self   )       ->					Any:
     return self.time_input_dim
    @property
    def 						UpperCamelCase_				(  self   )       ->					Tuple:
     return self.time_input_dim * 4
    @property
    def 						UpperCamelCase_				(  self   )       ->					int:
     return 100
    @property
    def 						UpperCamelCase_				(  self   )       ->					Dict:
     SCREAMING_SNAKE_CASE__:   List[str]=      CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''   )
     return tokenizer
    @property
    def 						UpperCamelCase_				(  self   )       ->					List[Any]:
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   Any=      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(lowerCAmelCase   )
    @property
    def 						UpperCamelCase_				(  self   )       ->					Optional[int]:
     torch.manual_seed(0   )

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

     SCREAMING_SNAKE_CASE__:   Optional[int]=      PriorTransformer(**lowerCAmelCase   )
     # 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
     SCREAMING_SNAKE_CASE__:   Tuple=      nn.Parameter(torch.ones(model.clip_std.shape   )   )
     return model
    @property
    def 						UpperCamelCase_				(  self   )       ->					Optional[Any]:
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   int=      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 , )

     SCREAMING_SNAKE_CASE__:   int=      CLIPVisionModelWithProjection(lowerCAmelCase   )
     return model
    @property
    def 						UpperCamelCase_				(  self   )       ->					Optional[Any]:
     SCREAMING_SNAKE_CASE__:   Optional[int]=      CLIPImageProcessor(
         crop_size=224 , do_center_crop=lowerCAmelCase , do_normalize=lowerCAmelCase , do_resize=lowerCAmelCase , image_mean=[0.48145466, 0.4578275, 0.40821073] , image_std=[0.26862954, 0.26130258, 0.27577711] , resample=3 , size=224 , )

     return image_processor
    def 						UpperCamelCase_				(  self   )       ->					Any:
     SCREAMING_SNAKE_CASE__:   List[str]=      self.dummy_prior
     SCREAMING_SNAKE_CASE__:   Tuple=      self.dummy_image_encoder
     SCREAMING_SNAKE_CASE__:   int=      self.dummy_text_encoder
     SCREAMING_SNAKE_CASE__:   Optional[int]=      self.dummy_tokenizer
     SCREAMING_SNAKE_CASE__:   Dict=      self.dummy_image_processor

     SCREAMING_SNAKE_CASE__:   List[Any]=      UnCLIPScheduler(
         variance_type='''fixed_small_log''' , prediction_type='''sample''' , num_train_timesteps=1000 , clip_sample=lowerCAmelCase , clip_sample_range=10.0 , )

     SCREAMING_SNAKE_CASE__:   List[Any]=      {
         '''prior''': prior,
         '''image_encoder''': image_encoder,
         '''text_encoder''': text_encoder,
         '''tokenizer''': tokenizer,
         '''scheduler''': scheduler,
         '''image_processor''': image_processor,
     }

     return components
    def 						UpperCamelCase_				(  self , lowerCAmelCase , lowerCAmelCase=0   )       ->					List[str]:
     if str(lowerCAmelCase   ).startswith('''mps'''   ):
      SCREAMING_SNAKE_CASE__:   List[str]=      torch.manual_seed(lowerCAmelCase   )
     else:
      SCREAMING_SNAKE_CASE__:   Optional[int]=      torch.Generator(device=lowerCAmelCase   ).manual_seed(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      {
         '''prompt''': '''horse''',
         '''generator''': generator,
         '''guidance_scale''': 4.0,
         '''num_inference_steps''': 2,
         '''output_type''': '''np''',
     }
     return inputs
    def 						UpperCamelCase_				(  self   )       ->					str:
     SCREAMING_SNAKE_CASE__:   int=      '''cpu'''

     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      self.get_dummy_components()

     SCREAMING_SNAKE_CASE__:   Dict=      self.pipeline_class(**lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      pipe.to(lowerCAmelCase   )

     pipe.set_progress_bar_config(disable=lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   Optional[Any]=      pipe(**self.get_dummy_inputs(lowerCAmelCase   )   )
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      output.image_embeds

     SCREAMING_SNAKE_CASE__:   Any=      pipe(
         **self.get_dummy_inputs(lowerCAmelCase   ) , return_dict=lowerCAmelCase , )[0]

     SCREAMING_SNAKE_CASE__:   Tuple=      image[0, -10:]
     SCREAMING_SNAKE_CASE__:   Optional[int]=      image_from_tuple[0, -10:]

     assert image.shape == (1, 32)

     SCREAMING_SNAKE_CASE__:   str=      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 						UpperCamelCase_				(  self   )       ->					str:
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      torch_device == '''cpu'''
     SCREAMING_SNAKE_CASE__:   List[str]=      True
     SCREAMING_SNAKE_CASE__:   Any=      False

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



    @skip_mps
    def 						UpperCamelCase_				(  self   )       ->					Optional[Any]:
     SCREAMING_SNAKE_CASE__:   str=      torch_device == '''cpu'''
     SCREAMING_SNAKE_CASE__:   Dict=      False

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


import re







def 			A__      (	snake_case_ :		str      ):

 if len(re.findall('''[ATCG]'''       ,				snake_case_      )      ) != len(snake_case_      ):
  raise ValueError('''Invalid Strand'''      )

 return dna.translate(dna.maketrans('''ATCG'''       ,				'''TAGC'''      )      )


if __name__ == "__main__":
      import doctest

      doctest.testmod()

