
'''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 			SCREAMING_SNAKE_CASE__      (     snake_case_							,       unittest.TestCase):
				lowerCAmelCase_     			=							VideoToVideoSDPipeline
				lowerCAmelCase_     			=							TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({"""video"""}) - {"""image""", """width""", """height"""}
				lowerCAmelCase_     			=							TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""video"""}) - {"""image"""}
				lowerCAmelCase_     			=							PipelineTesterMixin.required_optional_params - {"""latents"""}
				lowerCAmelCase_     			=							False

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







				def 						UpperCAmelCase_    (       self     )->		int:







											'''simple docstring'''






											torch.manual_seed(0     )
											UpperCamelCase   			=     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   			=     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     )
											UpperCamelCase   			=     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   			=     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=1000						,				hidden_act='gelu'						,				projection_dim=512						,				)
											UpperCamelCase   			=     CLIPTextModel(A_     )
											UpperCamelCase   			=     CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'     )

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







				def 						UpperCAmelCase_    (       self						,				A_						,				A_=0     )->		Optional[Any]:







											'''simple docstring'''






											UpperCamelCase   			=     floats_tensor((1, 3, 3, 32, 32)						,				rng=random.Random(A_     )     ).to(A_     )

											if str(A_     ).startswith('mps'     ):
																		UpperCamelCase   			=     torch.manual_seed(A_     )
											else:
																		UpperCamelCase   			=     torch.Generator(device=A_     ).manual_seed(A_     )
											UpperCamelCase   			=     {
											    '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     )->		str:







											'''simple docstring'''






											UpperCamelCase   			=     'cpu'  # ensure determinism for the device-dependent torch.Generator
											UpperCamelCase   			=     self.get_dummy_components()
											UpperCamelCase   			=     VideoToVideoSDPipeline(**A_     )
											UpperCamelCase   			=     sd_pipe.to(A_     )
											sd_pipe.set_progress_bar_config(disable=A_     )

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

											assert frames[0].shape == (32, 32, 3)
											UpperCamelCase   			=     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     )->		Tuple:







											'''simple docstring'''






											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 						UpperCAmelCase_    (       self     )->		Optional[Any]:







											'''simple docstring'''






											pass







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







											'''simple docstring'''






											pass







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







											'''simple docstring'''






											pass







				def 						UpperCAmelCase_    (       self     )->		Dict:







											'''simple docstring'''






											return super().test_progress_bar()


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







				def 						UpperCAmelCase_    (       self     )->		Dict:







											'''simple docstring'''






											UpperCamelCase   			=     VideoToVideoSDPipeline.from_pretrained('cerspense/zeroscope_v2_XL'						,				torch_dtype=torch.floataa     )
											pipe.enable_model_cpu_offload()

											# 10 frames
											UpperCamelCase   			=     torch.Generator(device='cpu'     ).manual_seed(0     )
											UpperCamelCase   			=     torch.randn((1, 10, 3, 1024, 576)						,				generator=A_     )
											UpperCamelCase   			=     video.to('cuda'     )

											UpperCamelCase   			=     'Spiderman is surfing'

											UpperCamelCase   			=     pipe(A_						,				video=A_						,				generator=A_						,				num_inference_steps=3						,				output_type='pt'     ).frames

											UpperCamelCase   			=     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





from __future__ import annotations


def 				lowerCAmelCase__       (			a__    ,     a__ = None    ,     a__ = None    ,     a__ = False    ,     )      ->tuple[int, float, str]:




  '''simple docstring'''

  _UpperCamelCase           =    cipher_alphabet or [chr(a__ ) for i in range(97    ,     123 )]

  # If the argument is None or the user provided an empty dictionary
  if not frequencies_dict:
    # Frequencies of letters in the english language (how much they show up)
    _UpperCamelCase           =    {
        "a": 0.08497,
        "b": 0.01492,
        "c": 0.02202,
        "d": 0.04253,
        "e": 0.11162,
        "f": 0.02228,
        "g": 0.02015,
        "h": 0.06094,
        "i": 0.07546,
        "j": 0.00153,
        "k": 0.01292,
        "l": 0.04025,
        "m": 0.02406,
        "n": 0.06749,
        "o": 0.07507,
        "p": 0.01929,
        "q": 0.00095,
        "r": 0.07587,
        "s": 0.06327,
        "t": 0.09356,
        "u": 0.02758,
        "v": 0.00978,
        "w": 0.02560,
        "x": 0.00150,
        "y": 0.01994,
        "z": 0.00077,
    }
  else:
    # Custom frequencies dictionary
    _UpperCamelCase           =    frequencies_dict

  if not case_sensitive:
    _UpperCamelCase           =    ciphertext.lower()

  # Chi squared statistic values
  _UpperCamelCase           =    {}

  # cycle through all of the shifts
  for shift in range(len(a__ ) ):
    _UpperCamelCase           =    ""

    # decrypt the message with the shift
    for letter in ciphertext:
      try:
        # Try to index the letter in the alphabet
        _UpperCamelCase           =    (alphabet_letters.index(letter.lower() ) - shift) % len(
            a__ )
        decrypted_with_shift += (
            alphabet_letters[new_key].upper()
            if case_sensitive and letter.isupper()
            else alphabet_letters[new_key]
        )
      except ValueError:
        # Append the character if it isn't in the alphabet
        decrypted_with_shift += letter

    _UpperCamelCase           =    0.0

    # Loop through each letter in the decoded message with the shift
    for letter in decrypted_with_shift:
      if case_sensitive:
        _UpperCamelCase           =    letter.lower()
        if letter in frequencies:
          # Get the amount of times the letter occurs in the message
          _UpperCamelCase           =    decrypted_with_shift.lower().count(a__ )

          # Get the excepcted amount of times the letter should appear based
          # on letter frequencies
          _UpperCamelCase           =    frequencies[letter] * occurrences

          # Complete the chi squared statistic formula
          _UpperCamelCase           =    ((occurrences - expected) ** 2) / expected

          # Add the margin of error to the total chi squared statistic
          chi_squared_statistic += chi_letter_value
      else:
        if letter.lower() in frequencies:
          # Get the amount of times the letter occurs in the message
          _UpperCamelCase           =    decrypted_with_shift.count(a__ )

          # Get the excepcted amount of times the letter should appear based
          # on letter frequencies
          _UpperCamelCase           =    frequencies[letter] * occurrences

          # Complete the chi squared statistic formula
          _UpperCamelCase           =    ((occurrences - expected) ** 2) / expected

          # Add the margin of error to the total chi squared statistic
          chi_squared_statistic += chi_letter_value

        # Add the data to the chi_squared_statistic_values dictionary
    _UpperCamelCase           =    (
        chi_squared_statistic,
        decrypted_with_shift,
    )

  # Get the most likely cipher by finding the cipher with the smallest chi squared
  # statistic
  def chi_squared_statistic_values_sorting_key(a__ ) -> tuple[float, str]:
    return chi_squared_statistic_values[key]

  _UpperCamelCase           =    min(
      a__    ,     key=a__    ,     )

  # Get all the data from the most likely cipher (key, decoded message)
  (
      (
      _UpperCamelCase
  )      ,						(
      _UpperCamelCase
  )      ,						
  )           =    chi_squared_statistic_values[most_likely_cipher]

  # Return the data on the most likely shift
  return (
      most_likely_cipher,
      most_likely_cipher_chi_squared_value,
      decoded_most_likely_cipher,
  )




