'''simple docstring'''

import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    UNetaDConditionModel,
    VideoToVideoSDPipeline,
)
from diffusers.utils import floats_tensor, is_xformers_available, skip_mps
from diffusers.utils.testing_utils import enable_full_determinism, slow, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


@skip_mps
class 				_lowercase	(      lowerCAmelCase		,unittest.TestCase   ):
      '''simple docstring'''


      UpperCAmelCase_      :      Union[str, Any]      							=   VideoToVideoSDPipeline
      UpperCAmelCase_      :      List[str]      							=   TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({'''video'''}   ) - {'''image''', '''width''', '''height'''}
      UpperCAmelCase_      :      Dict      							=   TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''video'''}   ) - {'''image'''}
      UpperCAmelCase_      :      List[str]      							=   PipelineTesterMixin.required_optional_params - {'''latents'''}
      UpperCAmelCase_      :      Union[str, Any]      							=   False

      # No `output_type`.
      UpperCAmelCase_      :      Optional[int]      							=   frozenset(
          [
              '''num_inference_steps''',
              '''generator''',
              '''latents''',
              '''return_dict''',
              '''callback''',
              '''callback_steps''',
          ]   )




      def 		lowerCAmelCase__					(				self							)			->			Optional[int]:



         '''simple docstring'''



         torch.manual_seed(0							)
         UpperCAmelCase__							:				Dict   				=  UNetaDConditionModel(
             block_out_channels=(32, 64, 64, 64)					,layers_per_block=2					,sample_size=32					,in_channels=4					,out_channels=4					,down_block_types=('''CrossAttnDownBlock3D''', '''CrossAttnDownBlock3D''', '''CrossAttnDownBlock3D''', '''DownBlock3D''')					,up_block_types=('''UpBlock3D''', '''CrossAttnUpBlock3D''', '''CrossAttnUpBlock3D''', '''CrossAttnUpBlock3D''')					,cross_attention_dim=32					,attention_head_dim=4					,)
         UpperCAmelCase__							:				List[Any]   				=  DDIMScheduler(
             beta_start=0.0_0085					,beta_end=0.012					,beta_schedule='''scaled_linear'''					,clip_sample=lowerCamelCase_					,set_alpha_to_one=lowerCamelCase_					,)
         torch.manual_seed(0							)
         UpperCAmelCase__							:				Union[str, Any]   				=  AutoencoderKL(
             block_out_channels=[32, 64]					,in_channels=3					,out_channels=3					,down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']					,up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']					,latent_channels=4					,sample_size=128					,)
         torch.manual_seed(0							)
         UpperCAmelCase__							:				Tuple   				=  CLIPTextConfig(
             bos_token_id=0					,eos_token_id=2					,hidden_size=32					,intermediate_size=37					,layer_norm_eps=1e-05					,num_attention_heads=4					,num_hidden_layers=5					,pad_token_id=1					,vocab_size=1000					,hidden_act='''gelu'''					,projection_dim=512					,)
         UpperCAmelCase__							:				List[str]   				=  CLIPTextModel(lowerCamelCase_							)
         UpperCAmelCase__							:				Union[str, Any]   				=  CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''							)

         UpperCAmelCase__							:				Dict   				=  {
             '''unet''': unet,
             '''scheduler''': scheduler,
             '''vae''': vae,
             '''text_encoder''': text_encoder,
             '''tokenizer''': tokenizer,
         }
         return components




      def 		lowerCAmelCase__					(				self					,lowerCamelCase_					,lowerCamelCase_=0							)			->			Optional[Any]:



         '''simple docstring'''



         UpperCAmelCase__							:				Tuple   				=  floats_tensor((1, 3, 3, 32, 32)					,rng=random.Random(lowerCamelCase_							)							).to(lowerCamelCase_							)

         if str(lowerCamelCase_							).startswith('''mps'''							):
            UpperCAmelCase__							:				int   				=  torch.manual_seed(lowerCamelCase_							)
         else:
            UpperCAmelCase__							:				int   				=  torch.Generator(device=lowerCamelCase_							).manual_seed(lowerCamelCase_							)
         UpperCAmelCase__							:				str   				=  {
             '''prompt''': '''A painting of a squirrel eating a burger''',
             '''video''': video,
             '''generator''': generator,
             '''num_inference_steps''': 2,
             '''guidance_scale''': 6.0,
             '''output_type''': '''pt''',
         }
         return inputs




      def 		lowerCAmelCase__					(				self							)			->			Dict:



         '''simple docstring'''



         UpperCAmelCase__							:				int   				=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
         UpperCAmelCase__							:				int   				=  self.get_dummy_components()
         UpperCAmelCase__							:				Union[str, Any]   				=  VideoToVideoSDPipeline(**lowerCamelCase_							)
         UpperCAmelCase__							:				Any   				=  sd_pipe.to(lowerCamelCase_							)
         sd_pipe.set_progress_bar_config(disable=lowerCamelCase_							)

         UpperCAmelCase__							:				Dict   				=  self.get_dummy_inputs(lowerCamelCase_							)
         UpperCAmelCase__							:				Union[str, Any]   				=  '''np'''
         UpperCAmelCase__							:				Optional[int]   				=  sd_pipe(**lowerCamelCase_							).frames
         UpperCAmelCase__							:				Optional[Any]   				=  frames[0][-3:, -3:, -1]

         assert frames[0].shape == (32, 32, 3)
         UpperCAmelCase__							:				str   				=  np.array([106, 117, 113, 174, 137, 112, 148, 151, 131]							)

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




      @unittest.skipIf(
          torch_device != '''cuda''' or not is_xformers_available()					,reason='''XFormers attention is only available with CUDA and `xformers` installed'''					,)
      def 		lowerCAmelCase__					(				self							)			->			Tuple:



         '''simple docstring'''



         self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCamelCase_					,expected_max_diff=5e-3							)




      @unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.'''							)
      def 		lowerCAmelCase__					(				self							)			->			Tuple:



         '''simple docstring'''



         pass




      @unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.'''							)
      def 		lowerCAmelCase__					(				self							)			->			List[str]:



         '''simple docstring'''



         pass




      @unittest.skip(reason='''`num_images_per_prompt` argument is not supported for this pipeline.'''							)
      def 		lowerCAmelCase__					(				self							)			->			Dict:



         '''simple docstring'''



         pass




      def 		lowerCAmelCase__					(				self							)			->			Optional[Any]:



         '''simple docstring'''



         return super().test_progress_bar()




@slow
@skip_mps
class 				_lowercase	(      unittest.TestCase   ):
      '''simple docstring'''


      def 		lowerCAmelCase__					(				self							)			->			Any:



         '''simple docstring'''



         UpperCAmelCase__							:				Optional[int]   				=  VideoToVideoSDPipeline.from_pretrained('''cerspense/zeroscope_v2_XL'''					,torch_dtype=torch.floataa							)
         pipe.enable_model_cpu_offload()

         # 10 frames
         UpperCAmelCase__							:				str   				=  torch.Generator(device='''cpu'''							).manual_seed(0							)
         UpperCAmelCase__							:				Optional[int]   				=  torch.randn((1, 10, 3, 1024, 576)					,generator=lowerCamelCase_							)
         UpperCAmelCase__							:				List[str]   				=  video.to('''cuda'''							)

         UpperCAmelCase__							:				Union[str, Any]   				=  '''Spiderman is surfing'''

         UpperCAmelCase__							:				int   				=  pipe(lowerCamelCase_					,video=lowerCamelCase_					,generator=lowerCamelCase_					,num_inference_steps=3					,output_type='''pt'''							).frames

         UpperCAmelCase__							:				Optional[int]   				=  np.array([-1.045_8984, -1.127_9297, -0.966_3086, -0.9150_3906, -0.7509_7656]							)
         assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array							).sum() < 1e-2




'''simple docstring'''

import re







def __UpperCamelCase(   _A					:				str    ):
   '''simple docstring'''

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

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


if __name__ == "__main__":
  import doctest

  doctest.testmod()




