


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					(	__snake_case			,       unittest.TestCase	):
      UpperCamelCase										=							VideoToVideoSDPipeline
      UpperCamelCase										=							TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({'''video'''}	) - {'''image''', '''width''', '''height'''}
      UpperCamelCase										=							TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''video'''}	) - {'''image'''}
      UpperCamelCase										=							PipelineTesterMixin.required_optional_params - {'''latents'''}
      UpperCamelCase										=							False

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





      def 							_lowercase					(		self    :       Any							)     -> List[Any]:






         """simple docstring"""







         torch.manual_seed(0							)
         UpperCAmelCase      					=  UNetaDConditionModel(
             block_out_channels=(3_2, 6_4, 6_4, 6_4)       ,							layers_per_block=2       ,							sample_size=3_2       ,							in_channels=4       ,							out_channels=4       ,							down_block_types=("""CrossAttnDownBlock3D""", """CrossAttnDownBlock3D""", """CrossAttnDownBlock3D""", """DownBlock3D""")       ,							up_block_types=("""UpBlock3D""", """CrossAttnUpBlock3D""", """CrossAttnUpBlock3D""", """CrossAttnUpBlock3D""")       ,							cross_attention_dim=3_2       ,							attention_head_dim=4       ,							)
         UpperCAmelCase      					=  DDIMScheduler(
             beta_start=0.00_085       ,							beta_end=0.012       ,							beta_schedule="""scaled_linear"""       ,							clip_sample=__lowerCamelCase       ,							set_alpha_to_one=__lowerCamelCase       ,							)
         torch.manual_seed(0							)
         UpperCAmelCase      					=  AutoencoderKL(
             block_out_channels=[3_2, 6_4]       ,							in_channels=3       ,							out_channels=3       ,							down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]       ,							up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]       ,							latent_channels=4       ,							sample_size=1_2_8       ,							)
         torch.manual_seed(0							)
         UpperCAmelCase      					=  CLIPTextConfig(
             bos_token_id=0       ,							eos_token_id=2       ,							hidden_size=3_2       ,							intermediate_size=3_7       ,							layer_norm_eps=1e-0_5       ,							num_attention_heads=4       ,							num_hidden_layers=5       ,							pad_token_id=1       ,							vocab_size=1_0_0_0       ,							hidden_act="""gelu"""       ,							projection_dim=5_1_2       ,							)
         UpperCAmelCase      					=  CLIPTextModel(__lowerCamelCase							)
         UpperCAmelCase      					=  CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

         UpperCAmelCase      					=  {
             """unet""": unet,
             """scheduler""": scheduler,
             """vae""": vae,
             """text_encoder""": text_encoder,
             """tokenizer""": tokenizer,
         }
         return components





      def 							_lowercase					(		self    :       List[str]       ,							__lowerCamelCase    :       Any       ,							__lowerCamelCase    :       Union[str, Any]=0							)     -> Dict:






         """simple docstring"""







         UpperCAmelCase      					=  floats_tensor((1, 3, 3, 3_2, 3_2)       ,							rng=random.Random(__lowerCamelCase							)							).to(__lowerCamelCase							)

         if str(__lowerCamelCase							).startswith("""mps"""							):
            UpperCAmelCase      					=  torch.manual_seed(__lowerCamelCase							)
         else:
            UpperCAmelCase      					=  torch.Generator(device=__lowerCamelCase							).manual_seed(__lowerCamelCase							)
         UpperCAmelCase      					=  {
             """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 							_lowercase					(		self    :       Any							)     -> int:






         """simple docstring"""







         UpperCAmelCase      					=  """cpu"""  # ensure determinism for the device-dependent torch.Generator
         UpperCAmelCase      					=  self.get_dummy_components()
         UpperCAmelCase      					=  VideoToVideoSDPipeline(**__lowerCamelCase							)
         UpperCAmelCase      					=  sd_pipe.to(__lowerCamelCase							)
         sd_pipe.set_progress_bar_config(disable=__lowerCamelCase							)

         UpperCAmelCase      					=  self.get_dummy_inputs(__lowerCamelCase							)
         UpperCAmelCase      					=  """np"""
         UpperCAmelCase      					=  sd_pipe(**__lowerCamelCase							).frames
         UpperCAmelCase      					=  frames[0][-3:, -3:, -1]

         assert frames[0].shape == (3_2, 3_2, 3)
         UpperCAmelCase      					=  np.array([1_0_6, 1_1_7, 1_1_3, 1_7_4, 1_3_7, 1_1_2, 1_4_8, 1_5_1, 1_3_1]							)

         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 							_lowercase					(		self    :       Any							)     -> Union[str, Any]:






         """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 							_lowercase					(		self    :       Union[str, Any]							)     -> Optional[Any]:






         """simple docstring"""







         pass





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






         """simple docstring"""







         pass





      @unittest.skip(reason="""`num_images_per_prompt` argument is not supported for this pipeline."""							)
      def 							_lowercase					(		self    :       List[str]							)     -> Union[str, Any]:






         """simple docstring"""







         pass





      def 							_lowercase					(		self    :       Tuple							)     -> Optional[Any]:






         """simple docstring"""







         return super().test_progress_bar()






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





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






         """simple docstring"""







         UpperCAmelCase      					=  VideoToVideoSDPipeline.from_pretrained("""cerspense/zeroscope_v2_XL"""       ,							torch_dtype=torch.floataa							)
         pipe.enable_model_cpu_offload()

         # 10 frames
         UpperCAmelCase      					=  torch.Generator(device="""cpu"""							).manual_seed(0							)
         UpperCAmelCase      					=  torch.randn((1, 1_0, 3, 1_0_2_4, 5_7_6)       ,							generator=__lowerCamelCase							)
         UpperCAmelCase      					=  video.to("""cuda"""							)

         UpperCAmelCase      					=  """Spiderman is surfing"""

         UpperCAmelCase      					=  pipe(__lowerCamelCase       ,							video=__lowerCamelCase       ,							generator=__lowerCamelCase       ,							num_inference_steps=3       ,							output_type="""pt"""							).frames

         UpperCAmelCase      					=  np.array([-1.0_458_984, -1.1_279_297, -0.9_663_086, -0.91_503_906, -0.75_097_656]							)
         assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array							).sum() < 1e-2







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


__a	 =      {"""configuration_reformer""": ["""REFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ReformerConfig"""]}

try:
 if not is_sentencepiece_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __a	 =      ["""ReformerTokenizer"""]

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __a	 =      ["""ReformerTokenizerFast"""]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __a	 =      [
     """REFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """ReformerAttention""",
     """ReformerForMaskedLM""",
     """ReformerForQuestionAnswering""",
     """ReformerForSequenceClassification""",
     """ReformerLayer""",
     """ReformerModel""",
     """ReformerModelWithLMHead""",
     """ReformerPreTrainedModel""",
 ]


if TYPE_CHECKING:
 from .configuration_reformer import REFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, ReformerConfig

 try:
  if not is_sentencepiece_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_reformer import ReformerTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_reformer_fast import ReformerTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_reformer import (
      REFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
      ReformerAttention,
      ReformerForMaskedLM,
      ReformerForQuestionAnswering,
      ReformerForSequenceClassification,
      ReformerLayer,
      ReformerModel,
      ReformerModelWithLMHead,
      ReformerPreTrainedModel,
  )

else:
 import sys

 __a	 =      _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



