


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





						"""simple docstring"""




						UpperCAmelCase__						:							Tuple       =  VideoToVideoSDPipeline
						UpperCAmelCase__						:							List[Any]       =  TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({'''video'''} ) - {'''image''', '''width''', '''height'''}
						UpperCAmelCase__						:							List[str]       =  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''video'''} ) - {'''image'''}
						UpperCAmelCase__						:							List[Any]       =  PipelineTesterMixin.required_optional_params - {'''latents'''}
						UpperCAmelCase__						:							str       =  False

						# No `output_type`.
						UpperCAmelCase__						:							List[str]       =  frozenset(
						    [
						        '''num_inference_steps''',
						        '''generator''',
						        '''latents''',
						        '''return_dict''',
						        '''callback''',
						        '''callback_steps''',
						    ] )
						def        __A       (			self					:       int	)				->       Optional[int]:
										torch.manual_seed(0	)
										__magic_name__							=			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						,					)
										__magic_name__							=			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	)
										__magic_name__							=			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	)
										__magic_name__							=			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						,					)
										__magic_name__							=			CLIPTextModel(_lowerCamelCase	)
										__magic_name__							=			CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

										__magic_name__							=			{
										    'unet': unet,
										    'scheduler': scheduler,
										    'vae': vae,
										    'text_encoder': text_encoder,
										    'tokenizer': tokenizer,
										}
										return components
						def        __A       (			self					:       Tuple						,					_lowerCamelCase					:       List[str]						,					_lowerCamelCase					:       List[str]=0	)				->       Optional[int]:
										# 3 frames
										__magic_name__							=			floats_tensor((1, 3, 3, 32, 32)						,					rng=random.Random(_lowerCamelCase	)	).to(_lowerCamelCase	)

										if str(_lowerCamelCase	).startswith("mps"	):
														__magic_name__							=			torch.manual_seed(_lowerCamelCase	)
										else:
														__magic_name__							=			torch.Generator(device=_lowerCamelCase	).manual_seed(_lowerCamelCase	)
										__magic_name__							=			{
										    '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        __A       (			self					:       str	)				->       Optional[int]:
										__magic_name__							=			'cpu'  # ensure determinism for the device-dependent torch.Generator
										__magic_name__							=			self.get_dummy_components()
										__magic_name__							=			VideoToVideoSDPipeline(**_lowerCamelCase	)
										__magic_name__							=			sd_pipe.to(_lowerCamelCase	)
										sd_pipe.set_progress_bar_config(disable=_lowerCamelCase	)

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

										assert frames[0].shape == (32, 32, 3)
										__magic_name__							=			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        __A       (			self					:       Any	)				->       List[str]:
										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        __A       (			self					:       Optional[Any]	)				->       str:
										pass
						@unittest.skip(reason="Batching needs to be properly figured out first for this pipeline."	)
						def        __A       (			self					:       Any	)				->       Union[str, Any]:
										pass
						@unittest.skip(reason="`num_images_per_prompt` argument is not supported for this pipeline."	)
						def        __A       (			self					:       Optional[Any]	)				->       Tuple:
										pass

						def        __A       (			self					:       str	)				->       Dict:
										return super().test_progress_bar()






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





						"""simple docstring"""




						def        __A       (			self					:       Union[str, Any]	)				->       Any:
										__magic_name__							=			VideoToVideoSDPipeline.from_pretrained("cerspense/zeroscope_v2_XL"						,					torch_dtype=torch.floataa	)
										pipe.enable_model_cpu_offload()

										# 10 frames
										__magic_name__							=			torch.Generator(device="cpu"	).manual_seed(0	)
										__magic_name__							=			torch.randn((1, 10, 3, 10_24, 5_76)						,					generator=_lowerCamelCase	)
										__magic_name__							=			video.to("cuda"	)

										__magic_name__							=			'Spiderman is surfing'

										__magic_name__							=			pipe(_lowerCamelCase						,					video=_lowerCamelCase						,					generator=_lowerCamelCase						,					num_inference_steps=3						,					output_type="pt"	).frames

										__magic_name__							=			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 qiskit







def 	_snake_case     (							lowercase__ = 2						):
				_lowerCamelCase	:     Optional[Any]       =       qubits

				# Using Aer's simulator
				_lowerCamelCase	:     Dict       =       qiskit.Aer.get_backend('aer_simulator'						)

				# Creating a Quantum Circuit acting on the q register
				_lowerCamelCase	:     Dict       =       qiskit.QuantumCircuit(lowercase__				,       lowercase__						)

				# Adding a H gate on qubit 0 (now q0 in superposition)
				circuit.h(0						)

				for i in range(1				,       lowercase__						):
								# Adding CX (CNOT) gate
								circuit.cx(i - 1				,       lowercase__						)

				# Mapping the quantum measurement to the classical bits
				circuit.measure(list(range(lowercase__						)						)				,       list(range(lowercase__						)						)						)

				# Now measuring any one qubit would affect other qubits to collapse
				# their super position and have same state as the measured one.

				# Executing the circuit on the simulator
				_lowerCamelCase	:     Optional[Any]       =       qiskit.execute(lowercase__				,       lowercase__				,       shots=1000						)

				return job.result().get_counts(lowercase__						)


if __name__ == "__main__":
			print(F"Total count for various states are: {quantum_entanglement(3)}")