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_     (   UpperCAmelCase_						,	unittest.TestCase ):






    '''simple docstring'''






    a__	:						str						=      TextToVideoSDPipeline
    a__	:						Union[str, Any]						=      TEXT_TO_IMAGE_PARAMS
    a__	:						Tuple						=      TEXT_TO_IMAGE_BATCH_PARAMS
    # No `output_type`.
    a__	:						int						=      frozenset(
        [
            """num_inference_steps""",
            """generator""",
            """latents""",
            """return_dict""",
            """callback""",
            """callback_steps""",
        ] )







    def 			UpperCamelCase__   (	self)       ->	Optional[Any]:
        torch.manual_seed(0)
        __UpperCamelCase     :str			  =		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     :Optional[int]			  =		DDIMScheduler(
            beta_start=0.0_00_85 , beta_end=0.0_12 , beta_schedule='''scaled_linear''' , clip_sample=__lowercase , set_alpha_to_one=__lowercase , )
        torch.manual_seed(0)
        __UpperCamelCase     :Optional[int]			  =		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     :Optional[int]			  =		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=1_000 , hidden_act='''gelu''' , projection_dim=512 , )
        __UpperCamelCase     :Optional[Any]			  =		CLIPTextModel(__lowercase)
        __UpperCamelCase     :Optional[int]			  =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

        __UpperCamelCase     :Union[str, Any]			  =		{
            '''unet''': unet,
            '''scheduler''': scheduler,
            '''vae''': vae,
            '''text_encoder''': text_encoder,
            '''tokenizer''': tokenizer,
        }
        return components







    def 			UpperCamelCase__   (	self , __lowercase , __lowercase=0)       ->	Optional[int]:
        if str(__lowercase).startswith('''mps'''):
            __UpperCamelCase     :List[Any]			  =		torch.manual_seed(__lowercase)
        else:
            __UpperCamelCase     :Tuple			  =		torch.Generator(device=__lowercase).manual_seed(__lowercase)
        __UpperCamelCase     :Dict			  =		{
            '''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 			UpperCamelCase__   (	self)       ->	Optional[Any]:
        __UpperCamelCase     :int			  =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
        __UpperCamelCase     :Optional[int]			  =		self.get_dummy_components()
        __UpperCamelCase     :Dict			  =		TextToVideoSDPipeline(**__lowercase)
        __UpperCamelCase     :Any			  =		sd_pipe.to(__lowercase)
        sd_pipe.set_progress_bar_config(disable=__lowercase)

        __UpperCamelCase     :Optional[Any]			  =		self.get_dummy_inputs(__lowercase)
        __UpperCamelCase     :int			  =		'''np'''
        __UpperCamelCase     :List[str]			  =		sd_pipe(**__lowercase).frames
        __UpperCamelCase     :Optional[Any]			  =		frames[0][-3:, -3:, -1]

        assert frames[0].shape == (64, 64, 3)
        __UpperCamelCase     :str			  =		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 			UpperCamelCase__   (	self)       ->	Tuple:
        self._test_attention_slicing_forward_pass(test_mean_pixel_difference=__lowercase , 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 			UpperCamelCase__   (	self)       ->	Optional[int]:
        self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__lowercase , expected_max_diff=1E-2)







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







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







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







    def 			UpperCamelCase__   (	self)       ->	List[str]:
        return super().test_progress_bar()


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






    '''simple docstring'''






    def 			UpperCamelCase__   (	self)       ->	Dict:
        __UpperCamelCase     :Union[str, Any]			  =		load_numpy(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy''')

        __UpperCamelCase     :List[str]			  =		TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b''')
        __UpperCamelCase     :Union[str, Any]			  =		DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
        __UpperCamelCase     :str			  =		pipe.to('''cuda''')

        __UpperCamelCase     :Optional[Any]			  =		'''Spiderman is surfing'''
        __UpperCamelCase     :Union[str, Any]			  =		torch.Generator(device='''cpu''').manual_seed(0)

        __UpperCamelCase     :List[Any]			  =		pipe(__lowercase , generator=__lowercase , num_inference_steps=25 , output_type='''pt''').frames
        __UpperCamelCase     :Optional[int]			  =		video_frames.cpu().numpy()

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







    def 			UpperCamelCase__   (	self)       ->	int:
        __UpperCamelCase     :str			  =		load_numpy(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy''')

        __UpperCamelCase     :Union[str, Any]			  =		TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b''')
        __UpperCamelCase     :str			  =		pipe.to('''cuda''')

        __UpperCamelCase     :Union[str, Any]			  =		'''Spiderman is surfing'''
        __UpperCamelCase     :int			  =		torch.Generator(device='''cpu''').manual_seed(0)

        __UpperCamelCase     :List[Any]			  =		pipe(__lowercase , generator=__lowercase , num_inference_steps=2 , output_type='''pt''').frames
        __UpperCamelCase     :Optional[Any]			  =		video_frames.cpu().numpy()

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






"""simple docstring"""
class    __snake_case       :



      def __init__(						self    ,			lowercase    ,			lowercase=None    ,			lowercase=None)	->			List[str]:





        '''simple docstring'''





        a__:     Dict										=	data
        a__:     List[Any]										=	previous
        a__:     Any										=	next_node



      def __str__(						self)	->			str:





        '''simple docstring'''





        return f'{self.data}'



      def   lowerCamelCase_   (						self)	->			int:





        '''simple docstring'''





        return self.data



      def   lowerCamelCase_   (						self)	->			Union[str, Any]:





        '''simple docstring'''





        return self.next



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





        '''simple docstring'''





        return self.previous







class    __snake_case       :



      def __init__(						self    ,			lowercase)	->			Dict:





        '''simple docstring'''





        a__:     List[Any]										=	head



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





        '''simple docstring'''





        return self



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





        '''simple docstring'''





        if not self.current:
          raise StopIteration
        else:
          a__:     Dict										=	self.current.get_data()
          a__:     Optional[Any]										=	self.current.get_next()
          return value







class    __snake_case       :



      def __init__(						self)	->			Dict:





        '''simple docstring'''





        a__:     List[Any]										=	None  # First node in list
        a__:     Optional[int]										=	None  # Last node in list



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





        '''simple docstring'''





        a__:     Dict										=	self.head
        a__:     Optional[Any]										=	[]
        while current is not None:
          nodes.append(current.get_data())
          a__:     str										=	current.get_next()
        return " ".join(str(lowercase) for node in nodes)



      def __contains__(						self    ,			lowercase)	->			Optional[int]:





        '''simple docstring'''





        a__:     Optional[int]										=	self.head
        while current:
          if current.get_data() == value:
            return True
          a__:     Dict										=	current.get_next()
        return False



      def __iter__(						self)	->			int:





        '''simple docstring'''





        return LinkedListIterator(self.head)



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





        '''simple docstring'''





        if self.head:
          return self.head.get_data()
        return None



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





        '''simple docstring'''





        if self.tail:
          return self.tail.get_data()
        return None



      def   lowerCamelCase_   (						self    ,			lowercase)	->			None:





        '''simple docstring'''





        if self.head is None:
          a__:     Optional[Any]										=	node
          a__:     Optional[Any]										=	node
        else:
          self.insert_before_node(self.head    ,			lowercase)



      def   lowerCamelCase_   (						self    ,			lowercase)	->			None:





        '''simple docstring'''





        if self.head is None:
          self.set_head(lowercase)
        else:
          self.insert_after_node(self.tail    ,			lowercase)



      def   lowerCamelCase_   (						self    ,			lowercase)	->			None:





        '''simple docstring'''





        a__:     Tuple										=	Node(lowercase)
        if self.head is None:
          self.set_head(lowercase)
        else:
          self.set_tail(lowercase)



      def   lowerCamelCase_   (						self    ,			lowercase    ,			lowercase)	->			None:





        '''simple docstring'''





        a__:     Union[str, Any]										=	node
        a__:     Optional[Any]										=	node.previous

        if node.get_previous() is None:
          a__:     Tuple										=	node_to_insert
        else:
          a__:     int										=	node_to_insert

        a__:     Optional[int]										=	node_to_insert



      def   lowerCamelCase_   (						self    ,			lowercase    ,			lowercase)	->			None:





        '''simple docstring'''





        a__:     Optional[int]										=	node
        a__:     Tuple										=	node.next

        if node.get_next() is None:
          a__:     Optional[int]										=	node_to_insert
        else:
          a__:     Any										=	node_to_insert

        a__:     str										=	node_to_insert



      def   lowerCamelCase_   (						self    ,			lowercase    ,			lowercase)	->			None:





        '''simple docstring'''





        a__:     Any										=	1
        a__:     Tuple										=	Node(lowercase)
        a__:     Tuple										=	self.head
        while node:
          if current_position == position:
            self.insert_before_node(lowercase    ,			lowercase)
            return
          current_position += 1
          a__:     List[Any]										=	node.next
        self.insert_after_node(self.tail    ,			lowercase)



      def   lowerCamelCase_   (						self    ,			lowercase)	->			Node:





        '''simple docstring'''





        a__:     Tuple										=	self.head
        while node:
          if node.get_data() == item:
            return node
          a__:     List[str]										=	node.get_next()
        raise Exception('Node not found')



      def   lowerCamelCase_   (						self    ,			lowercase)	->			Any:





        '''simple docstring'''





        if (node := self.get_node(lowercase)) is not None:
          if node == self.head:
            a__:     Any										=	self.head.get_next()

          if node == self.tail:
            a__:     List[Any]										=	self.tail.get_previous()

          self.remove_node_pointers(lowercase)



      @staticmethod
      def   lowerCamelCase_   (						lowercase)	->			None:





        '''simple docstring'''





        if node.get_next():
          a__:     Any										=	node.previous

        if node.get_previous():
          a__:     List[str]										=	node.next

        a__:     int										=	None
        a__:     Union[str, Any]										=	None



      def   lowerCamelCase_   (						self)	->			str:





        '''simple docstring'''





        return self.head is None







def 						__a   (	)	->None:
  pass


if __name__ == "__main__":
 import doctest

 doctest.testmod()


