


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





							"""simple docstring"""







							_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 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										torch.manual_seed(0       )
										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					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			,						)
										SCREAMING_SNAKE_CASE_		:     Any					=					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       )
										SCREAMING_SNAKE_CASE_		:     List[str]					=					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       )
										SCREAMING_SNAKE_CASE_		:     Any					=					CLIPTextConfig(
										    bos_token_id=0			,						eos_token_id=2			,						hidden_size=3_2			,						intermediate_size=3_7			,						layer_norm_eps=1E-05			,						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			,						)
										SCREAMING_SNAKE_CASE_		:     List[str]					=					CLIPTextModel(lowerCAmelCase__       )
										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'       )

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






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__			,						lowerCAmelCase__=0       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     int					=					floats_tensor((1, 3, 3, 3_2, 3_2)			,						rng=random.Random(lowerCAmelCase__       )       ).to(lowerCAmelCase__       )

										if str(lowerCAmelCase__       ).startswith('mps'       ):
													SCREAMING_SNAKE_CASE_		:     int					=					torch.manual_seed(lowerCAmelCase__       )
										else:
													SCREAMING_SNAKE_CASE_		:     Any					=					torch.Generator(device=lowerCAmelCase__       ).manual_seed(lowerCAmelCase__       )
										SCREAMING_SNAKE_CASE_		:     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 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Optional[int]					=					'cpu'  # ensure determinism for the device-dependent torch.Generator
										SCREAMING_SNAKE_CASE_		:     Tuple					=					self.get_dummy_components()
										SCREAMING_SNAKE_CASE_		:     Dict					=					VideoToVideoSDPipeline(**lowerCAmelCase__       )
										SCREAMING_SNAKE_CASE_		:     Dict					=					sd_pipe.to(lowerCAmelCase__       )
										sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

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

										assert frames[0].shape == (3_2, 3_2, 3)
										SCREAMING_SNAKE_CASE_		:     str					=					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 					UpperCamelCase__     (      self       ):





										"""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 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										pass






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





										"""simple docstring"""




										pass






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





										"""simple docstring"""




										pass






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										return super().test_progress_bar()







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





							"""simple docstring"""







							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     List[str]					=					VideoToVideoSDPipeline.from_pretrained('cerspense/zeroscope_v2_XL'			,						torch_dtype=torch.floataa       )
										pipe.enable_model_cpu_offload()

										# 10 frames
										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					torch.Generator(device='cpu'       ).manual_seed(0       )
										SCREAMING_SNAKE_CASE_		:     List[str]					=					torch.randn((1, 1_0, 3, 1_0_2_4, 5_7_6)			,						generator=lowerCAmelCase__       )
										SCREAMING_SNAKE_CASE_		:     Dict					=					video.to('cuda'       )

										SCREAMING_SNAKE_CASE_		:     List[Any]					=					'Spiderman is surfing'

										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					pipe(lowerCAmelCase__			,						video=lowerCAmelCase__			,						generator=lowerCAmelCase__			,						num_inference_steps=3			,						output_type='pt'       ).frames

										SCREAMING_SNAKE_CASE_		:     str					=					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









# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import torch

from ..models.speechta import SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaProcessor
from ..utils import is_datasets_available
from .base import PipelineTool


if is_datasets_available():
				from datasets import load_dataset







class 	__lowercase    (__SCREAMING_SNAKE_CASE  ):





							"""simple docstring"""







							_UpperCAmelCase      =						"""microsoft/speecht5_tts"""
							_UpperCAmelCase      =						(
							    """This is a tool that reads an English text out loud. It takes an input named `text` which should contain the """
							    """text to read (in English) and returns a waveform object containing the sound."""
							)
							_UpperCAmelCase      =						"""text_reader"""
							_UpperCAmelCase      =						SpeechTaProcessor
							_UpperCAmelCase      =						SpeechTaForTextToSpeech
							_UpperCAmelCase      =						SpeechTaHifiGan

							_UpperCAmelCase      =						["""text"""]
							_UpperCAmelCase      =						["""audio"""]






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										if self.post_processor is None:
													SCREAMING_SNAKE_CASE_		:     List[Any]					=					'microsoft/speecht5_hifigan'
										super().setup()






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__			,						lowerCAmelCase__=None       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     int					=					self.pre_processor(text=lowerCAmelCase__			,						return_tensors='pt'			,						truncation=lowerCAmelCase__       )

										if speaker_embeddings is None:
													if not is_datasets_available():
																raise ImportError('Datasets needs to be installed if not passing speaker embeddings.'       )

													SCREAMING_SNAKE_CASE_		:     List[Any]					=					load_dataset('Matthijs/cmu-arctic-xvectors'			,						split='validation'       )
													SCREAMING_SNAKE_CASE_		:     Optional[int]					=					torch.tensor(embeddings_dataset[7_3_0_5]['xvector']       ).unsqueeze(0       )

										return {"input_ids": inputs["input_ids"], "speaker_embeddings": speaker_embeddings}






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__       ):





										"""simple docstring"""




										with torch.no_grad():
													return self.model.generate_speech(**lowerCAmelCase__       )






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__       ):





										"""simple docstring"""




										with torch.no_grad():
													return self.post_processor(lowerCAmelCase__       ).cpu().detach()





