


"""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     __lowerCamelCase  (					a__  ,					unittest.TestCase				):

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

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


     def 							_UpperCAmelCase      (      self							)       ->							Any:
          torch.manual_seed(0							)
          _a    	=				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    ,				)
          _a    	=				DDIMScheduler(
              beta_start=0.00085    ,				beta_end=0.012    ,				beta_schedule='''scaled_linear'''    ,				clip_sample=__UpperCAmelCase    ,				set_alpha_to_one=__UpperCAmelCase    ,				)
          torch.manual_seed(0							)
          _a    	=				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							)
          _a    	=				CLIPTextConfig(
              bos_token_id=0    ,				eos_token_id=2    ,				hidden_size=32    ,				intermediate_size=37    ,				layer_norm_eps=1e-0_5    ,				num_attention_heads=4    ,				num_hidden_layers=5    ,				pad_token_id=1    ,				vocab_size=1000    ,				hidden_act='''gelu'''    ,				projection_dim=512    ,				)
          _a    	=				CLIPTextModel(__UpperCAmelCase							)
          _a    	=				CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''							)

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


     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase=0							)       ->							Dict:
          # 3 frames
          _a    	=				floats_tensor((1, 3, 3, 32, 32)    ,				rng=random.Random(__UpperCAmelCase							)							).to(__UpperCAmelCase							)

          if str(__UpperCAmelCase							).startswith('''mps'''							):
               _a    	=				torch.manual_seed(__UpperCAmelCase							)
          else:
               _a    	=				torch.Generator(device=__UpperCAmelCase							).manual_seed(__UpperCAmelCase							)
          _a    	=				{
              '''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 							_UpperCAmelCase      (      self							)       ->							str:
          _a    	=				'''cpu'''  # ensure determinism for the device-dependent torch.Generator
          _a    	=				self.get_dummy_components()
          _a    	=				VideoToVideoSDPipeline(**__UpperCAmelCase							)
          _a    	=				sd_pipe.to(__UpperCAmelCase							)
          sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase							)

          _a    	=				self.get_dummy_inputs(__UpperCAmelCase							)
          _a    	=				'''np'''
          _a    	=				sd_pipe(**__UpperCAmelCase							).frames
          _a    	=				frames[0][-3:, -3:, -1]

          assert frames[0].shape == (32, 32, 3)
          _a    	=				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 							_UpperCAmelCase      (      self							)       ->							int:
          self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__UpperCAmelCase    ,				expected_max_diff=5e-3							)


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


     @unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.'''							)
     def 							_UpperCAmelCase      (      self							)       ->							Optional[int]:
          pass


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





     def 							_UpperCAmelCase      (      self							)       ->							Union[str, Any]:
          return super().test_progress_bar()







@slow
@skip_mps
class     __lowerCamelCase  (					unittest.TestCase				):

     '''simple docstring'''


     def 							_UpperCAmelCase      (      self							)       ->							Dict:
          _a    	=				VideoToVideoSDPipeline.from_pretrained('''cerspense/zeroscope_v2_XL'''    ,				torch_dtype=torch.floataa							)
          pipe.enable_model_cpu_offload()

          # 10 frames
          _a    	=				torch.Generator(device='''cpu'''							).manual_seed(0							)
          _a    	=				torch.randn((1, 10, 3, 1024, 576)    ,				generator=__UpperCAmelCase							)
          _a    	=				video.to('''cuda'''							)

          _a    	=				'''Spiderman is surfing'''

          _a    	=				pipe(__UpperCAmelCase    ,				video=__UpperCAmelCase    ,				generator=__UpperCAmelCase    ,				num_inference_steps=3    ,				output_type='''pt'''							).frames

          _a    	=				np.array([-1.0458984, -1.1279297, -0.9663086, -0.91503906, -0.75097656]							)
          assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array							).sum() < 1e-2



"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


__snake_case		=       {'''configuration_vit_mae''': ['''VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ViTMAEConfig''']}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   __snake_case		=       [
       '''VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''ViTMAEForPreTraining''',
       '''ViTMAELayer''',
       '''ViTMAEModel''',
       '''ViTMAEPreTrainedModel''',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   __snake_case		=       [
       '''TFViTMAEForPreTraining''',
       '''TFViTMAEModel''',
       '''TFViTMAEPreTrainedModel''',
   ]

if TYPE_CHECKING:
   from .configuration_vit_mae import VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMAEConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_vit_mae import (
          VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST,
          ViTMAEForPreTraining,
          ViTMAELayer,
          ViTMAEModel,
          ViTMAEPreTrainedModel,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_vit_mae import TFViTMAEForPreTraining, TFViTMAEModel, TFViTMAEPreTrainedModel


else:
   import sys

   __snake_case		=       _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)