



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





	"""simple docstring"""
	__A							=							VideoToVideoSDPipeline
	__A							=							TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({"video"}	) - {"image", "width", "height"}
	__A							=							TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"video"}	) - {"image"}
	__A							=							PipelineTesterMixin.required_optional_params - {"latents"}
	__A							=							False

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




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						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.0_0085		,       beta_end=0.012		,       beta_schedule="scaled_linear"		,       clip_sample=lowerCamelCase_		,       set_alpha_to_one=lowerCamelCase_		,       )
						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(lowerCamelCase_		)
						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		,       lowerCamelCase_		,       lowerCamelCase_=0		):
						"""simple docstring"""

						a					     =   floats_tensor((1, 3, 3, 32, 32)		,       rng=random.Random(lowerCamelCase_		)		).to(lowerCamelCase_		)

						if str(lowerCamelCase_		).startswith("mps"		):
											a					     =   torch.manual_seed(lowerCamelCase_		)
						else:
											a					     =   torch.Generator(device=lowerCamelCase_		).manual_seed(lowerCamelCase_		)
						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		):
						"""simple docstring"""

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

						a					     =   self.get_dummy_inputs(lowerCamelCase_		)
						a					     =   "np"
						a					     =   sd_pipe(**lowerCamelCase_		).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		):
						"""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"""

						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=lowerCamelCase_		)
						a					     =   video.to("cuda"		)

						a					     =   "Spiderman is surfing"

						a					     =   pipe(lowerCamelCase_		,       video=lowerCamelCase_		,       generator=lowerCamelCase_		,       num_inference_steps=3		,       output_type="pt"		).frames

						a					     =   np.array([-1.045_8984, -1.127_9297, -0.966_3086, -0.9150_3906, -0.7509_7656]		)
						assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array		).sum() < 1E-2





import unittest

from transformers.models.xlm_prophetnet.tokenization_xlm_prophetnet import SPIECE_UNDERLINE, XLMProphetNetTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


_lowercase: Optional[int]      			=		get_tests_dir("fixtures/test_sentencepiece.model")



@require_sentencepiece
class 	_lowercase							(   lowerCAmelCase,      unittest.TestCase	):





	"""simple docstring"""
	__A							=							XLMProphetNetTokenizer
	__A							=							False
	__A							=							True




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						super().setUp()

						# We have a SentencePiece fixture for testing
						a					     =   XLMProphetNetTokenizer(lowerCamelCase_		,       keep_accents=lowerCamelCase_		)
						tokenizer.save_pretrained(self.tmpdirname		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   "[PAD]"
						a					     =   0

						self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase_		)		,       lowerCamelCase_		)
						self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase_		)		,       lowerCamelCase_		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   list(self.get_tokenizer().get_vocab().keys()		)

						self.assertEqual(vocab_keys[0]		,       "[PAD]"		)
						self.assertEqual(vocab_keys[1]		,       "[CLS]"		)
						self.assertEqual(vocab_keys[-1]		,       "j"		)
						self.assertEqual(len(lowerCamelCase_		)		,       1012		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						self.assertEqual(self.get_tokenizer().vocab_size		,       1012		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   XLMProphetNetTokenizer(lowerCamelCase_		,       keep_accents=lowerCamelCase_		)

						a					     =   tokenizer.tokenize("This is a test"		)
						self.assertListEqual(lowerCamelCase_		,       ["▁This", "▁is", "▁a", "▁t", "est"]		)

						self.assertListEqual(
						    tokenizer.convert_tokens_to_ids(lowerCamelCase_		)		,       [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]		,       )

						a					     =   tokenizer.tokenize("I was born in 92000, and this is falsé."		)
						self.assertListEqual(
						    lowerCamelCase_		,       [
						        SPIECE_UNDERLINE + "I",
						        SPIECE_UNDERLINE + "was",
						        SPIECE_UNDERLINE + "b",
						        "or",
						        "n",
						        SPIECE_UNDERLINE + "in",
						        SPIECE_UNDERLINE + "",
						        "9",
						        "2",
						        "0",
						        "0",
						        "0",
						        ",",
						        SPIECE_UNDERLINE + "and",
						        SPIECE_UNDERLINE + "this",
						        SPIECE_UNDERLINE + "is",
						        SPIECE_UNDERLINE + "f",
						        "al",
						        "s",
						        "é",
						        ".",
						    ]		,       )
						a					     =   tokenizer.convert_tokens_to_ids(lowerCamelCase_		)
						self.assertListEqual(
						    lowerCamelCase_		,       [
						        value + tokenizer.fairseq_offset
						        for value in [8, 21, 84, 55, 24, 19, 7, -9, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, -9, 4]
						    ]		,       )

						a					     =   tokenizer.convert_ids_to_tokens(lowerCamelCase_		)
						self.assertListEqual(
						    lowerCamelCase_		,       [
						        SPIECE_UNDERLINE + "I",
						        SPIECE_UNDERLINE + "was",
						        SPIECE_UNDERLINE + "b",
						        "or",
						        "n",
						        SPIECE_UNDERLINE + "in",
						        SPIECE_UNDERLINE + "",
						        "[UNK]",
						        "2",
						        "0",
						        "0",
						        "0",
						        ",",
						        SPIECE_UNDERLINE + "and",
						        SPIECE_UNDERLINE + "this",
						        SPIECE_UNDERLINE + "is",
						        SPIECE_UNDERLINE + "f",
						        "al",
						        "s",
						        "[UNK]",
						        ".",
						    ]		,       )




	@cached_property
	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						return XLMProphetNetTokenizer.from_pretrained("microsoft/xprophetnet-large-wiki100-cased"		)




	@slow
	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   "Hello World!"
						a					     =   [35389, 6672, 49, 2]
						self.assertListEqual(lowerCamelCase_		,       self.big_tokenizer.encode(lowerCamelCase_		)		)




	@slow
	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   {"input_ids": [[11073, 82783, 18, 26, 82783, 549, 51540, 248, 17209, 1301, 217, 20, 215186, 1325, 147, 17209, 1301, 217, 20, 56370, 53, 122020, 20, 16477, 27, 87355, 4548, 20, 4728, 78392, 17, 159969, 18, 26, 24491, 629, 15, 538, 22704, 5439, 15, 2788, 24491, 9885, 15, 43534, 605, 15, 814, 18403, 33200, 29, 15, 43534, 24458, 12410, 111, 24966, 83669, 9637, 144068, 26, 850, 22346, 27, 147, 24966, 83669, 83490, 26, 39113, 735, 27, 689, 656, 2800, 1339, 4600, 53, 122020, 115785, 34, 816, 1339, 46887, 18, 147, 53905, 1951, 42238, 41170, 17732, 834, 436, 15, 27523, 98733, 217, 147, 5542, 4981, 930, 17347, 16, 2], [20091, 629, 94, 82786, 58, 490, 20, 1528, 84, 53905, 344, 80592, 110128, 18822, 5267, 1306, 62, 152537, 308, 7997, 401, 124427, 549, 35442, 225, 109, 15055, 25748, 147, 7119, 43712, 34, 767, 135366, 18, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [592, 63784, 119466, 17, 147808, 88214, 18, 656, 81, 32, 3296, 10280, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
						# fmt: on

						self.tokenizer_integration_test_util(
						    expected_encoding=lowerCamelCase_		,       model_name="microsoft/xprophetnet-large-wiki100-cased"		,       revision="1acad1643ddd54a44df6a1b797ada8373685d90e"		,       )
