



'''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 	_lowerCAmelCase							(			_snake_case      ,			unittest.TestCase ):
	__SCREAMING_SNAKE_CASE   :		List[str]					=					VideoToVideoSDPipeline
	__SCREAMING_SNAKE_CASE   :		Optional[Any]					=					TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({'video'} ) - {"""image""", """width""", """height"""}
	__SCREAMING_SNAKE_CASE   :		Optional[Any]					=					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'video'} ) - {"""image"""}
	__SCREAMING_SNAKE_CASE   :		Optional[Any]					=					PipelineTesterMixin.required_optional_params - {"""latents"""}
	__SCREAMING_SNAKE_CASE   :		Any					=					False

	# No `output_type`.
	__SCREAMING_SNAKE_CASE   :		Optional[Any]					=					frozenset(
	    [
	        'num_inference_steps',
	        'generator',
	        'latents',
	        'return_dict',
	        'callback',
	        'callback_steps',
	    ] )


	def     _a	(self							):
				torch.manual_seed(0							)
				A_	:						Optional[int]	=     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_	:						Union[str, Any]	=     DDIMScheduler(
				    beta_start=0.0_00_85       ,      beta_end=0.0_12       ,      beta_schedule="""scaled_linear"""       ,      clip_sample=__snake_case       ,      set_alpha_to_one=__snake_case       ,      )
				torch.manual_seed(0							)
				A_	:						List[Any]	=     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_	:						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=1000       ,      hidden_act="""gelu"""       ,      projection_dim=512       ,      )
				A_	:						Dict	=     CLIPTextModel(__snake_case							)
				A_	:						Union[str, Any]	=     CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

				A_	:						str	=     {
				    """unet""": unet,
				    """scheduler""": scheduler,
				    """vae""": vae,
				    """text_encoder""": text_encoder,
				    """tokenizer""": tokenizer,
				}
				return components


	def     _a	(self       ,      lowercase       ,      lowercase=0							):
				# 3 frames
				A_	:						List[Any]	=     floats_tensor((1, 3, 3, 32, 32)       ,      rng=random.Random(__snake_case							)							).to(__snake_case							)

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

				A_	:						Tuple	=     self.get_dummy_inputs(__snake_case							)
				A_	:						List[str]	=     """np"""
				A_	:						int	=     sd_pipe(**__snake_case							).frames
				A_	:						str	=     frames[0][-3:, -3:, -1]

				assert frames[0].shape == (32, 32, 3)
				A_	:						List[str]	=     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     _a	(self							):
				self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__snake_case       ,      expected_max_diff=5E-3							)


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


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


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


	def     _a	(self							):
				return super().test_progress_bar()







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


	def     _a	(self							):
				A_	:						Tuple	=     VideoToVideoSDPipeline.from_pretrained("""cerspense/zeroscope_v2_XL"""       ,      torch_dtype=torch.floataa							)
				pipe.enable_model_cpu_offload()

				# 10 frames
				A_	:						List[str]	=     torch.Generator(device="""cpu"""							).manual_seed(0							)
				A_	:						Optional[Any]	=     torch.randn((1, 10, 3, 1024, 576)       ,      generator=__snake_case							)
				A_	:						Tuple	=     video.to("""cuda"""							)

				A_	:						str	=     """Spiderman is surfing"""

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

				A_	:						Optional[int]	=     np.array([-1.0_45_89_84, -1.1_27_92_97, -0.9_66_30_86, -0.91_50_39_06, -0.75_09_76_56]							)
				assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array							).sum() < 1E-2



'''simple docstring'''


from typing import Any





class     lowercase__  :





							'''simple docstring'''


							def __init__(    self    ,					__snake_case  ):
											_SCREAMING_SNAKE_CASE :       Dict     		=      data
											_SCREAMING_SNAKE_CASE :       Optional[int]     		=      None






							def __repr__(    self  ):
											return f"""Node({self.data})"""





class     lowercase__  :





							'''simple docstring'''


							def __init__(    self  ):
											_SCREAMING_SNAKE_CASE :       Any     		=      None






							def __iter__(    self  ):
											_SCREAMING_SNAKE_CASE :       Any     		=      self.head
											while node:
															yield node.data
															_SCREAMING_SNAKE_CASE :       List[Any]     		=      node.next






							def __len__(    self  ):
											return sum(1 for _ in self  )






							def __repr__(    self  ):
											return "->".join([str(__snake_case  ) for item in self]  )






							def __getitem__(    self    ,					__snake_case  ):
											if not 0 <= index < len(self  ):
															raise ValueError("""list index out of range."""  )
											for i, node in enumerate(self  ):
															if i == index:
																			return node
											return None






							def __setitem__(    self    ,					__snake_case    ,					__snake_case  ):
											if not 0 <= index < len(self  ):
															raise ValueError("""list index out of range."""  )
											_SCREAMING_SNAKE_CASE :       Any     		=      self.head
											for _ in range(__snake_case  ):
															_SCREAMING_SNAKE_CASE :       List[Any]     		=      current.next
											_SCREAMING_SNAKE_CASE :       Dict     		=      data






							def UpperCAmelCase_	(    self    ,					__snake_case  ):
											self.insert_nth(len(self  )    ,					__snake_case  )






							def UpperCAmelCase_	(    self    ,					__snake_case  ):
											self.insert_nth(0    ,					__snake_case  )






							def UpperCAmelCase_	(    self    ,					__snake_case    ,					__snake_case  ):
											if not 0 <= index <= len(self  ):
															raise IndexError("""list index out of range"""  )
											_SCREAMING_SNAKE_CASE :       Optional[int]     		=      Node(__snake_case  )
											if self.head is None:
															_SCREAMING_SNAKE_CASE :       str     		=      new_node
											elif index == 0:
															_SCREAMING_SNAKE_CASE :       Tuple     		=      self.head  # link new_node to head
															_SCREAMING_SNAKE_CASE :       str     		=      new_node
											else:
															_SCREAMING_SNAKE_CASE :       Tuple     		=      self.head
															for _ in range(index - 1  ):
																			_SCREAMING_SNAKE_CASE :       List[str]     		=      temp.next
															_SCREAMING_SNAKE_CASE :       Tuple     		=      temp.next
															_SCREAMING_SNAKE_CASE :       Dict     		=      new_node






							def UpperCAmelCase_	(    self  ):  # print every node data
											print(self  )






							def UpperCAmelCase_	(    self  ):
											return self.delete_nth(0  )






							def UpperCAmelCase_	(    self  ):  # delete from tail
											return self.delete_nth(len(self  ) - 1  )






							def UpperCAmelCase_	(    self    ,					__snake_case = 0  ):
											if not 0 <= index <= len(self  ) - 1:  # test if index is valid
															raise IndexError("""List index out of range."""  )
											_SCREAMING_SNAKE_CASE :       Tuple     		=      self.head  # default first node
											if index == 0:
															_SCREAMING_SNAKE_CASE :       List[Any]     		=      self.head.next
											else:
															_SCREAMING_SNAKE_CASE :       Tuple     		=      self.head
															for _ in range(index - 1  ):
																			_SCREAMING_SNAKE_CASE :       Any     		=      temp.next
															_SCREAMING_SNAKE_CASE :       Any     		=      temp.next
															_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      temp.next.next
											return delete_node.data






							def UpperCAmelCase_	(    self  ):
											return self.head is None






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE :       Dict     		=      None
											_SCREAMING_SNAKE_CASE :       int     		=      self.head

											while current:
															# Store the current node's next node.
															_SCREAMING_SNAKE_CASE :       List[Any]     		=      current.next
															# Make the current node's next point backwards
															_SCREAMING_SNAKE_CASE :       Tuple     		=      prev
															# Make the previous node be the current node
															_SCREAMING_SNAKE_CASE :       int     		=      current
															# Make the current node the next node (to progress iteration)
															_SCREAMING_SNAKE_CASE :       Any     		=      next_node
											# Return prev in order to put the head at the end
											_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      prev







def 			snake_case_   (  ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE :       Dict     		=      LinkedList()
				assert linked_list.is_empty() is True
				assert str(SCREAMING_SNAKE_CASE__     ) == ""

				try:
								linked_list.delete_head()
								raise AssertionError  # This should not happen.
				except IndexError:
								assert True  # This should happen.

				try:
								linked_list.delete_tail()
								raise AssertionError  # This should not happen.
				except IndexError:
								assert True  # This should happen.

				for i in range(10     ):
								assert len(SCREAMING_SNAKE_CASE__     ) == i
								linked_list.insert_nth(SCREAMING_SNAKE_CASE__							,      i + 1     )
				assert str(SCREAMING_SNAKE_CASE__     ) == "->".join(str(SCREAMING_SNAKE_CASE__     ) for i in range(1							,      11     )     )

				linked_list.insert_head(0     )
				linked_list.insert_tail(11     )
				assert str(SCREAMING_SNAKE_CASE__     ) == "->".join(str(SCREAMING_SNAKE_CASE__     ) for i in range(0							,      12     )     )

				assert linked_list.delete_head() == 0
				assert linked_list.delete_nth(9     ) == 10
				assert linked_list.delete_tail() == 11
				assert len(SCREAMING_SNAKE_CASE__     ) == 9
				assert str(SCREAMING_SNAKE_CASE__     ) == "->".join(str(SCREAMING_SNAKE_CASE__     ) for i in range(1							,      10     )     )

				assert all(linked_list[i] == i + 1 for i in range(0							,      9     )     ) is True

				for i in range(0							,      9     ):
								_SCREAMING_SNAKE_CASE :       List[str]     		=      -i
				assert all(linked_list[i] == -i for i in range(0							,      9     )     ) is True

				linked_list.reverse()
				assert str(SCREAMING_SNAKE_CASE__     ) == "->".join(str(SCREAMING_SNAKE_CASE__     ) for i in range(-8							,      1     )     )







def 			snake_case_   (  ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE :       Optional[int]     		=      [
				    -9,
				    100,
				    Node(7734_5112     ),
				    """dlrow olleH""",
				    7,
				    5555,
				    0,
				    -1_9_2.5_5_5_5_5,
				    """Hello, world!""",
				    7_7.9,
				    Node(10     ),
				    None,
				    None,
				    1_2.2_0,
				]
				_SCREAMING_SNAKE_CASE :       Optional[int]     		=      LinkedList()

				for i in test_input:
								linked_list.insert_tail(SCREAMING_SNAKE_CASE__     )

				# Check if it's empty or not
				assert linked_list.is_empty() is False
				assert (
				    str(SCREAMING_SNAKE_CASE__     ) == "-9->100->Node(77345112)->dlrow olleH->7->5555->0->"
				    "-192.55555->Hello, world!->77.9->Node(10)->None->None->12.2"
				)

				# Delete the head
				_SCREAMING_SNAKE_CASE :       Any     		=      linked_list.delete_head()
				assert result == -9
				assert (
				    str(SCREAMING_SNAKE_CASE__     ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
				    "Hello, world!->77.9->Node(10)->None->None->12.2"
				)

				# Delete the tail
				_SCREAMING_SNAKE_CASE :       List[Any]     		=      linked_list.delete_tail()
				assert result == 1_2.2
				assert (
				    str(SCREAMING_SNAKE_CASE__     ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
				    "Hello, world!->77.9->Node(10)->None->None"
				)

				# Delete a node in specific location in linked list
				_SCREAMING_SNAKE_CASE :       Optional[int]     		=      linked_list.delete_nth(10     )
				assert result is None
				assert (
				    str(SCREAMING_SNAKE_CASE__     ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
				    "Hello, world!->77.9->Node(10)->None"
				)

				# Add a Node instance to its head
				linked_list.insert_head(Node("""Hello again, world!"""     )     )
				assert (
				    str(SCREAMING_SNAKE_CASE__     )
				    == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
				    "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None"
				)

				# Add None to its tail
				linked_list.insert_tail(SCREAMING_SNAKE_CASE__     )
				assert (
				    str(SCREAMING_SNAKE_CASE__     )
				    == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
				    "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None->None"
				)

				# Reverse the linked list
				linked_list.reverse()
				assert (
				    str(SCREAMING_SNAKE_CASE__     )
				    == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
				    "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
				)







def 			snake_case_   (  ):







				"""simple docstring"""





				from doctest import testmod

				testmod()

				_SCREAMING_SNAKE_CASE :       Optional[int]     		=      LinkedList()
				linked_list.insert_head(input("""Inserting 1st at head """     ).strip()     )
				linked_list.insert_head(input("""Inserting 2nd at head """     ).strip()     )
				print("""\nPrint list:"""     )
				linked_list.print_list()
				linked_list.insert_tail(input("""\nInserting 1st at tail """     ).strip()     )
				linked_list.insert_tail(input("""Inserting 2nd at tail """     ).strip()     )
				print("""\nPrint list:"""     )
				linked_list.print_list()
				print("""\nDelete head"""     )
				linked_list.delete_head()
				print("""Delete tail"""     )
				linked_list.delete_tail()
				print("""\nPrint list:"""     )
				linked_list.print_list()
				print("""\nReverse linked list"""     )
				linked_list.reverse()
				print("""\nPrint list:"""     )
				linked_list.print_list()
				print("""\nString representation of linked list:"""     )
				print(SCREAMING_SNAKE_CASE__     )
				print("""\nReading/changing Node data using indexing:"""     )
				print(f"""Element at Position 1: {linked_list[1]}"""     )
				_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      input("""Enter New Value: """     ).strip()
				print("""New list:"""     )
				print(SCREAMING_SNAKE_CASE__     )
				print(f"""length of linked_list is : {len(SCREAMING_SNAKE_CASE__     )}"""     )


if __name__ == "__main__":
				main()




