


"""simple docstring"""

import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()





@skip_mps
class    lowerCamelCase__						(		_a			,   unittest.TestCase    ):
      a :     Optional[int]											=		TextToVideoSDPipeline
      a :     Dict											=		TEXT_TO_IMAGE_PARAMS
      a :     List[Any]											=		TEXT_TO_IMAGE_BATCH_PARAMS
      # No `output_type`.
      a :     Dict											=		frozenset(
          [
              """num_inference_steps""",
              """generator""",
              """latents""",
              """return_dict""",
              """callback""",
              """callback_steps""",
          ]    )
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[Any]							):






       '''simple docstring'''


       torch.manual_seed(0							)
       __lowercase									=	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      ,       )
       __lowercase									=	DDIMScheduler(
           beta_start=0.0_00_85      ,       beta_end=0.0_12      ,       beta_schedule="""scaled_linear"""      ,       clip_sample=A_      ,       set_alpha_to_one=A_      ,       )
       torch.manual_seed(0							)
       __lowercase									=	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							)
       __lowercase									=	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      ,       )
       __lowercase									=	CLIPTextModel(A_							)
       __lowercase									=	CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

       __lowercase									=	{
           """unet""": unet,
           """scheduler""": scheduler,
           """vae""": vae,
           """text_encoder""": text_encoder,
           """tokenizer""": tokenizer,
       }
       return components
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[Any]      ,       A_	:	Union[str, Any]      ,       A_	:	str=0							):






       '''simple docstring'''


       if str(A_							).startswith("""mps"""							):
        __lowercase									=	torch.manual_seed(A_							)
       else:
        __lowercase									=	torch.Generator(device=A_							).manual_seed(A_							)
       __lowercase									=	{
           """prompt""": """A painting of a squirrel eating a burger""",
           """generator""": generator,
           """num_inference_steps""": 2,
           """guidance_scale""": 6.0,
           """output_type""": """pt""",
       }
       return inputs
      def SCREAMING_SNAKE_CASE_	(		self	:	int							):






       '''simple docstring'''


       __lowercase									=	"""cpu"""  # ensure determinism for the device-dependent torch.Generator
       __lowercase									=	self.get_dummy_components()
       __lowercase									=	TextToVideoSDPipeline(**A_							)
       __lowercase									=	sd_pipe.to(A_							)
       sd_pipe.set_progress_bar_config(disable=A_							)

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

       assert frames[0].shape == (6_4, 6_4, 3)
       __lowercase									=	np.array([1_58.0, 1_60.0, 1_53.0, 1_25.0, 1_00.0, 1_21.0, 1_11.0, 93.0, 1_13.0]							)

       assert np.abs(image_slice.flatten() - expected_slice							).max() < 1e-2
      def SCREAMING_SNAKE_CASE_	(		self	:	List[Any]							):






       '''simple docstring'''


       self._test_attention_slicing_forward_pass(test_mean_pixel_difference=A_      ,       expected_max_diff=3e-3							)
      @unittest.skipIf(
          torch_device != """cuda""" or not is_xformers_available()      ,       reason="""XFormers attention is only available with CUDA and `xformers` installed"""      ,       )
      def SCREAMING_SNAKE_CASE_	(		self	:	Any							):






       '''simple docstring'''


       self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=A_      ,       expected_max_diff=1e-2							)
      @unittest.skip(reason="""Batching needs to be properly figured out first for this pipeline."""							)
      def SCREAMING_SNAKE_CASE_	(		self	:	List[Any]							):






       '''simple docstring'''


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






       '''simple docstring'''


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






       '''simple docstring'''


       pass






      def SCREAMING_SNAKE_CASE_	(		self	:	str							):






       '''simple docstring'''


       return super().test_progress_bar()






@slow
@skip_mps
class    lowerCamelCase__						(		unittest.TestCase    ):
      def SCREAMING_SNAKE_CASE_	(		self	:	str							):






       '''simple docstring'''


       __lowercase									=	load_numpy(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy"""							)

       __lowercase									=	TextToVideoSDPipeline.from_pretrained("""damo-vilab/text-to-video-ms-1.7b"""							)
       __lowercase									=	DPMSolverMultistepScheduler.from_config(pipe.scheduler.config							)
       __lowercase									=	pipe.to("""cuda"""							)

       __lowercase									=	"""Spiderman is surfing"""
       __lowercase									=	torch.Generator(device="""cpu"""							).manual_seed(0							)

       __lowercase									=	pipe(A_      ,       generator=A_      ,       num_inference_steps=2_5      ,       output_type="""pt"""							).frames
       __lowercase									=	video_frames.cpu().numpy()

       assert np.abs(expected_video - video							).mean() < 5e-2






      def SCREAMING_SNAKE_CASE_	(		self	:	int							):






       '''simple docstring'''


       __lowercase									=	load_numpy(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy"""							)

       __lowercase									=	TextToVideoSDPipeline.from_pretrained("""damo-vilab/text-to-video-ms-1.7b"""							)
       __lowercase									=	pipe.to("""cuda"""							)

       __lowercase									=	"""Spiderman is surfing"""
       __lowercase									=	torch.Generator(device="""cpu"""							).manual_seed(0							)

       __lowercase									=	pipe(A_      ,       generator=A_      ,       num_inference_steps=2      ,       output_type="""pt"""							).frames
       __lowercase									=	video_frames.cpu().numpy()

       assert np.abs(expected_video - video							).mean() < 5e-2




"""simple docstring"""

from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase__  							=logging.get_logger(__name__)

UpperCAmelCase__  							={
    "microsoft/swinv2-tiny-patch4-window8-256": (
        "https://huggingface.co/microsoft/swinv2-tiny-patch4-window8-256/resolve/main/config.json"
    ),
}





class    lowerCamelCase__						(		_a    ):
      a :     List[Any]											=		"""swinv2"""

      a :     Any											=		{
          """num_attention_heads""": """num_heads""",
          """num_hidden_layers""": """num_layers""",
      }
      def __init__(		self	:	List[str]      ,       A_	:	Any=2_2_4      ,       A_	:	int=4      ,       A_	:	Optional[int]=3      ,       A_	:	List[Any]=9_6      ,       A_	:	List[Any]=[2, 2, 6, 2]      ,       A_	:	List[str]=[3, 6, 1_2, 2_4]      ,       A_	:	Union[str, Any]=7      ,       A_	:	int=4.0      ,       A_	:	List[str]=True      ,       A_	:	str=0.0      ,       A_	:	Any=0.0      ,       A_	:	Union[str, Any]=0.1      ,       A_	:	Optional[Any]="gelu"      ,       A_	:	int=False      ,       A_	:	List[Any]=0.02      ,       A_	:	Tuple=1e-5      ,       A_	:	Tuple=3_2      ,       **A_	:	int      ,       ):






       '''simple docstring'''


       super().__init__(**A_							)

       __lowercase									=	image_size
       __lowercase									=	patch_size
       __lowercase									=	num_channels
       __lowercase									=	embed_dim
       __lowercase									=	depths
       __lowercase									=	len(A_							)
       __lowercase									=	num_heads
       __lowercase									=	window_size
       __lowercase									=	mlp_ratio
       __lowercase									=	qkv_bias
       __lowercase									=	hidden_dropout_prob
       __lowercase									=	attention_probs_dropout_prob
       __lowercase									=	drop_path_rate
       __lowercase									=	hidden_act
       __lowercase									=	use_absolute_embeddings
       __lowercase									=	layer_norm_eps
       __lowercase									=	initializer_range
       __lowercase									=	encoder_stride
       # we set the hidden_size attribute in order to make Swinv2 work with VisionEncoderDecoderModel
       # this indicates the channel dimension after the last stage of the model
       __lowercase									=	int(embed_dim * 2 ** (len(A_							) - 1)							)
       __lowercase									=	(0, 0, 0, 0)
