"""simple docstring"""







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 		UpperCamelCase      (   lowercase				,     unittest.TestCase						):
				UpperCAmelCase    :				int   =		VideoToVideoSDPipeline
				UpperCAmelCase    :				Tuple   =		TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({"""video"""}						) - {"""image""", """width""", """height"""}
				UpperCAmelCase    :				Optional[int]   =		TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""video"""}						) - {"""image"""}
				UpperCAmelCase    :				Union[str, Any]   =		PipelineTesterMixin.required_optional_params - {"""latents"""}
				UpperCAmelCase    :				int   =		False

				# No `output_type`.
				UpperCAmelCase    :				List[str]   =		frozenset(
				    [
				        """num_inference_steps""",
				        """generator""",
				        """latents""",
				        """return_dict""",
				        """callback""",
				        """callback_steps""",
				    ]						)



				def  _lowercase					(self    :				int)   ->     Tuple:
					torch.manual_seed(0)
					__snake_case      :							Optional[Any]						=			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     ,  )
					__snake_case      :							Optional[Any]						=			DDIMScheduler(
					    beta_start=0.00_085     ,  beta_end=0.012     ,  beta_schedule='scaled_linear'     ,  clip_sample=_A     ,  set_alpha_to_one=_A     ,  )
					torch.manual_seed(0)
					__snake_case      :							Dict						=			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=1_28     ,  )
					torch.manual_seed(0)
					__snake_case      :							Dict						=			CLIPTextConfig(
					    bos_token_id=0     ,  eos_token_id=2     ,  hidden_size=32     ,  intermediate_size=37     ,  layer_norm_eps=1E-05     ,  num_attention_heads=4     ,  num_hidden_layers=5     ,  pad_token_id=1     ,  vocab_size=10_00     ,  hidden_act='gelu'     ,  projection_dim=5_12     ,  )
					__snake_case      :							Any						=			CLIPTextModel(_A)
					__snake_case      :							List[str]						=			CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

					__snake_case      :							str						=			{
					    'unet': unet,
					    'scheduler': scheduler,
					    'vae': vae,
					    'text_encoder': text_encoder,
					    'tokenizer': tokenizer,
					}
					return components



				def  _lowercase					(self    :				Optional[int]     ,  _A    :				Union[str, Any]     ,  _A    :				Tuple=0)   ->     str:
					# 3 frames
					__snake_case      :							int						=			floats_tensor((1, 3, 3, 32, 32)     ,  rng=random.Random(_A)).to(_A)

					if str(_A).startswith('mps'):
						__snake_case      :							Union[str, Any]						=			torch.manual_seed(_A)
					else:
						__snake_case      :							str						=			torch.Generator(device=_A).manual_seed(_A)
					__snake_case      :							Union[str, Any]						=			{
					    '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    :				str)   ->     Tuple:
					__snake_case      :							str						=			'cpu'  # ensure determinism for the device-dependent torch.Generator
					__snake_case      :							Any						=			self.get_dummy_components()
					__snake_case      :							List[str]						=			VideoToVideoSDPipeline(**_A)
					__snake_case      :							List[str]						=			sd_pipe.to(_A)
					sd_pipe.set_progress_bar_config(disable=_A)

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

					assert frames[0].shape == (32, 32, 3)
					__snake_case      :							str						=			np.array([1_06, 1_17, 1_13, 1_74, 1_37, 1_12, 1_48, 1_51, 1_31])

					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    :				List[str])   ->     List[Any]:
					self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=_A     ,  expected_max_diff=5E-3)



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



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



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






				def  _lowercase					(self    :				Optional[Any])   ->     int:
					return super().test_progress_bar()







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



				def  _lowercase					(self    :				List[Any])   ->     int:
					__snake_case      :							Optional[Any]						=			VideoToVideoSDPipeline.from_pretrained('cerspense/zeroscope_v2_XL'     ,  torch_dtype=torch.floataa)
					pipe.enable_model_cpu_offload()

					# 10 frames
					__snake_case      :							Optional[int]						=			torch.Generator(device='cpu').manual_seed(0)
					__snake_case      :							int						=			torch.randn((1, 10, 3, 10_24, 5_76)     ,  generator=_A)
					__snake_case      :							List[str]						=			video.to('cuda')

					__snake_case      :							Any						=			'Spiderman is surfing'

					__snake_case      :							int						=			pipe(_A     ,  video=_A     ,  generator=_A     ,  num_inference_steps=3     ,  output_type='pt').frames

					__snake_case      :							Optional[Any]						=			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






"""simple docstring"""







import itertools
import string
from collections.abc import Generator, Iterable
def   __UpperCAmelCase    (   UpperCAmelCase_   :    Iterable[str]      ,							UpperCAmelCase_   :    int  )							->      Generator[tuple[str, ...], None, None]:

	'''simple docstring'''





	__snake_case      :							Optional[int]						=			iter(UpperCAmelCase_  )
	while True:
		__snake_case      :							Optional[int]						=			tuple(itertools.islice(UpperCAmelCase_      ,							UpperCAmelCase_  )  )
		if not chunk:
			return
		yield chunk
def   __UpperCAmelCase    (   UpperCAmelCase_   :    str  )							->      str:

	'''simple docstring'''





	__snake_case      :							Any						=			''.join([c.upper() for c in dirty if c in string.ascii_letters]  )
	__snake_case      :							Union[str, Any]						=			''

	if len(UpperCAmelCase_  ) < 2:
		return dirty

	for i in range(len(UpperCAmelCase_  ) - 1  ):
		clean += dirty[i]

		if dirty[i] == dirty[i + 1]:
			clean += "X"

	clean += dirty[-1]

	if len(UpperCAmelCase_  ) & 1:
		clean += "X"

	return clean
def   __UpperCAmelCase    (   UpperCAmelCase_   :    str  )							->      list[str]:

	'''simple docstring'''





	__snake_case      :							List[str]						=			'ABCDEFGHIKLMNOPQRSTUVWXYZ'
	# we're using a list instead of a '2d' array because it makes the math
	# for setting up the table and doing the actual encoding/decoding simpler
	__snake_case      :							Optional[int]						=			[]

	# copy key chars into the table if they are in `alphabet` ignoring duplicates
	for char in key.upper():
		if char not in table and char in alphabet:
			table.append(UpperCAmelCase_  )

    # fill the rest of the table in with the remaining alphabet chars
	for char in alphabet:
		if char not in table:
			table.append(UpperCAmelCase_  )

	return table
def   __UpperCAmelCase    (   UpperCAmelCase_   :    str      ,							UpperCAmelCase_   :    str  )							->      str:

	'''simple docstring'''





	__snake_case      :							str						=			generate_table(UpperCAmelCase_  )
	__snake_case      :							Union[str, Any]						=			prepare_input(UpperCAmelCase_  )
	__snake_case      :							Tuple						=			''

	# https://en.wikipedia.org/wiki/Playfair_cipher#Description
	for chara, chara in chunker(UpperCAmelCase_      ,							2  ):
		__snake_case		,    __snake_case      :							Any						=			divmod(table.index(UpperCAmelCase_  )      ,							5  )
		__snake_case		,    __snake_case      :							Tuple						=			divmod(table.index(UpperCAmelCase_  )      ,							5  )

		if rowa == rowa:
			ciphertext += table[rowa * 5 + (cola + 1) % 5]
			ciphertext += table[rowa * 5 + (cola + 1) % 5]
		elif cola == cola:
			ciphertext += table[((rowa + 1) % 5) * 5 + cola]
			ciphertext += table[((rowa + 1) % 5) * 5 + cola]
		else:  # rectangle
			ciphertext += table[rowa * 5 + cola]
			ciphertext += table[rowa * 5 + cola]

	return ciphertext

def   __UpperCAmelCase    (   UpperCAmelCase_   :    str      ,							UpperCAmelCase_   :    str  )							->      str:

	'''simple docstring'''





	__snake_case      :							Optional[int]						=			generate_table(UpperCAmelCase_  )
	__snake_case      :							Any						=			''

	# https://en.wikipedia.org/wiki/Playfair_cipher#Description
	for chara, chara in chunker(UpperCAmelCase_      ,							2  ):
		__snake_case		,    __snake_case      :							Union[str, Any]						=			divmod(table.index(UpperCAmelCase_  )      ,							5  )
		__snake_case		,    __snake_case      :							Tuple						=			divmod(table.index(UpperCAmelCase_  )      ,							5  )

		if rowa == rowa:
			plaintext += table[rowa * 5 + (cola - 1) % 5]
			plaintext += table[rowa * 5 + (cola - 1) % 5]
		elif cola == cola:
			plaintext += table[((rowa - 1) % 5) * 5 + cola]
			plaintext += table[((rowa - 1) % 5) * 5 + cola]
		else:  # rectangle
			plaintext += table[rowa * 5 + cola]
			plaintext += table[rowa * 5 + cola]

	return plaintext





