





'''simple docstring'''







from __future__ import annotations

from random import random
from typing import Generic, TypeVar

snake_case_     :       List[str]						=  TypeVar("KT")
snake_case_     :       int						=  TypeVar("VT")


class 					__a      (Generic[KT, VT]     ):

							def __init__(							self							:     Union[str, Any]       ,     __magic_name__							:     KT | str = "root"       ,     __magic_name__							:     VT | None = None   )					->       str:







													"""simple docstring"""
													UpperCAmelCase_			:      str     						=  key
													UpperCAmelCase_			:      Dict     						=  value
													UpperCAmelCase_			:      list[Node[KT, VT]]     						=  []

							def __repr__(							self							:     Optional[Any]   )					->       str:







													"""simple docstring"""
													return F"""Node({self.key}: {self.value})"""



							@property
							def     UpperCAmelCase__	(							self							:     Any   )					->       int:







													"""simple docstring"""
													return len(self.forward   )





class 					__a      (Generic[KT, VT]     ):

							def __init__(							self							:     str       ,     __magic_name__							:     float = 0.5       ,     __magic_name__							:     int = 16   )					->       Any:







													"""simple docstring"""
													UpperCAmelCase_			:      Node[KT, VT]     						=  Node[KT, VT]()
													UpperCAmelCase_			:      Dict     						=  0
													UpperCAmelCase_			:      Tuple     						=  p
													UpperCAmelCase_			:      Tuple     						=  max_level

							def __str__(							self							:     Optional[Any]   )					->       str:







													"""simple docstring"""
													UpperCAmelCase_			:      Optional[Any]     						=  list(self   )

													if len(__magic_name__   ) == 0:
																			return F"""SkipList(level={self.level})"""

													UpperCAmelCase_			:      Tuple     						=  max((len(str(__magic_name__   )   ) for item in items)       ,     default=4   )
													UpperCAmelCase_			:      Tuple     						=  max(__magic_name__       ,     4   ) + 4

													UpperCAmelCase_			:      Dict     						=  self.head
													UpperCAmelCase_			:      str     						=  []

													UpperCAmelCase_			:      int     						=  node.forward.copy()
													lines.append(F"""[{node.key}]""".ljust(__magic_name__       ,     '''-'''   ) + '''* ''' * len(__magic_name__   )   )
													lines.append(''' ''' * label_size + '''| ''' * len(__magic_name__   )   )

													while len(node.forward   ) != 0:
																			UpperCAmelCase_			:      str     						=  node.forward[0]

																			lines.append(
																			    F"""[{node.key}]""".ljust(__magic_name__       ,     '''-'''   )
																			    + ''' '''.join(str(n.key   ) if n.key == node.key else '''|''' for n in forwards   )   )
																			lines.append(''' ''' * label_size + '''| ''' * len(__magic_name__   )   )
																			UpperCAmelCase_			:      List[Any]     						=  node.forward

													lines.append('''None'''.ljust(__magic_name__   ) + '''* ''' * len(__magic_name__   )   )
													return F"""SkipList(level={self.level})\n""" + "\n".join(__magic_name__   )

							def __iter__(							self							:     Optional[Any]   )					->       Optional[Any]:







													"""simple docstring"""
													UpperCAmelCase_			:      Union[str, Any]     						=  self.head

													while len(node.forward   ) != 0:
																			yield node.forward[0].key
																			UpperCAmelCase_			:      Any     						=  node.forward[0]

							def     UpperCAmelCase__	(							self							:     Any   )					->       int:







													"""simple docstring"""
													UpperCAmelCase_			:      Optional[Any]     						=  1
													while random() < self.p and level < self.max_level:
																			level += 1

													return level

							def     UpperCAmelCase__	(							self							:     Optional[Any]       ,     __magic_name__							:     str   )					->       tuple[Node[KT, VT] | None, list[Node[KT, VT]]]:







													"""simple docstring"""
													UpperCAmelCase_			:      List[str]     						=  []

													UpperCAmelCase_			:      str     						=  self.head

													for i in reversed(range(self.level   )   ):
																			# i < node.level - When node level is lesser than `i` decrement `i`.
																			# node.forward[i].key < key - Jumping to node with key value higher
																			#                             or equal to searched key would result
																			#                             in skipping searched key.
																			while i < node.level and node.forward[i].key < key:
																									UpperCAmelCase_			:      int     						=  node.forward[i]
																			# Each leftmost node (relative to searched node) will potentially have to
																			# be updated.
																			update_vector.append(__magic_name__   )

													update_vector.reverse()  # Note that we were inserting values in reverse order.

													# len(node.forward) != 0 - If current node doesn't contain any further
													#                          references then searched key is not present.
													# node.forward[0].key == key - Next node key should be equal to search key
													#                              if key is present.
													if len(node.forward   ) != 0 and node.forward[0].key == key:
																			return node.forward[0], update_vector
													else:
																			return None, update_vector

							def     UpperCAmelCase__	(							self							:     int       ,     __magic_name__							:     KT   )					->       List[str]:







													"""simple docstring"""
													UpperCAmelCase_						,       UpperCAmelCase_			:      Any     						=  self._locate_node(__magic_name__   )

													if node is not None:
																			for i, update_node in enumerate(__magic_name__   ):
																									# Remove or replace all references to removed node.
																									if update_node.level > i and update_node.forward[i].key == key:
																															if node.level > i:
																																					UpperCAmelCase_			:      Optional[int]     						=  node.forward[i]
																															else:
																																					UpperCAmelCase_			:      List[Any]     						=  update_node.forward[:i]

							def     UpperCAmelCase__	(							self							:     str       ,     __magic_name__							:     KT       ,     __magic_name__							:     VT   )					->       List[Any]:







													"""simple docstring"""
													UpperCAmelCase_						,       UpperCAmelCase_			:      Dict     						=  self._locate_node(__magic_name__   )
													if node is not None:
																			UpperCAmelCase_			:      str     						=  value
													else:
																			UpperCAmelCase_			:      Optional[Any]     						=  self.random_level()

																			if level > self.level:
																									# After level increase we have to add additional nodes to head.
																									for _ in range(self.level - 1       ,     __magic_name__   ):
																															update_vector.append(self.head   )
																									UpperCAmelCase_			:      int     						=  level

																			UpperCAmelCase_			:      Optional[int]     						=  Node(__magic_name__       ,     __magic_name__   )

																			for i, update_node in enumerate(update_vector[:level]   ):
																									# Change references to pass through new node.
																									if update_node.level > i:
																															new_node.forward.append(update_node.forward[i]   )

																									if update_node.level < i + 1:
																															update_node.forward.append(__magic_name__   )
																									else:
																															UpperCAmelCase_			:      Tuple     						=  new_node



							def     UpperCAmelCase__	(							self							:     Any       ,     __magic_name__							:     VT   )					->       VT | None:







													"""simple docstring"""
													UpperCAmelCase_						,       UpperCAmelCase_			:      Tuple     						=  self._locate_node(__magic_name__   )

													if node is not None:
																			return node.value

													return None





def        lowerCamelCase_      (  ) ->	List[Any]:
						UpperCAmelCase_			:      List[Any]     						=  SkipList()
						skip_list.insert('''Key1''',			3   )
						skip_list.insert('''Key2''',			12   )
						skip_list.insert('''Key3''',			41   )
						skip_list.insert('''Key4''',			-19   )

						UpperCAmelCase_			:      Dict     						=  skip_list.head
						UpperCAmelCase_			:      Any     						=  {}
						while node.level != 0:
												UpperCAmelCase_			:      List[str]     						=  node.forward[0]
												UpperCAmelCase_			:      Any     						=  node.value

						assert len(SCREAMING_SNAKE_CASE__   ) == 4
						assert all_values["Key1"] == 3
						assert all_values["Key2"] == 12
						assert all_values["Key3"] == 41
						assert all_values["Key4"] == -19





def        lowerCamelCase_      (  ) ->	Any:
						UpperCAmelCase_			:      List[str]     						=  SkipList()
						skip_list.insert('''Key1''',			10   )
						skip_list.insert('''Key1''',			12   )

						skip_list.insert('''Key5''',			7   )
						skip_list.insert('''Key7''',			10   )
						skip_list.insert('''Key10''',			5   )

						skip_list.insert('''Key7''',			7   )
						skip_list.insert('''Key5''',			5   )
						skip_list.insert('''Key10''',			10   )

						UpperCAmelCase_			:      Optional[Any]     						=  skip_list.head
						UpperCAmelCase_			:      Dict     						=  {}
						while node.level != 0:
												UpperCAmelCase_			:      List[Any]     						=  node.forward[0]
												UpperCAmelCase_			:      Dict     						=  node.value

						if len(SCREAMING_SNAKE_CASE__   ) != 4:
												print()
						assert len(SCREAMING_SNAKE_CASE__   ) == 4
						assert all_values["Key1"] == 12
						assert all_values["Key7"] == 7
						assert all_values["Key5"] == 5
						assert all_values["Key10"] == 10





def        lowerCamelCase_      (  ) ->	Union[str, Any]:
						UpperCAmelCase_			:      Any     						=  SkipList()
						assert skip_list.find('''Some key'''   ) is None





def        lowerCamelCase_      (  ) ->	Optional[Any]:
						UpperCAmelCase_			:      Optional[Any]     						=  SkipList()

						skip_list.insert('''Key2''',			20   )
						assert skip_list.find('''Key2'''   ) == 20

						skip_list.insert('''Some Key''',			10   )
						skip_list.insert('''Key2''',			8   )
						skip_list.insert('''V''',			13   )

						assert skip_list.find('''Y'''   ) is None
						assert skip_list.find('''Key2'''   ) == 8
						assert skip_list.find('''Some Key'''   ) == 10
						assert skip_list.find('''V'''   ) == 13





def        lowerCamelCase_      (  ) ->	Optional[int]:
						UpperCAmelCase_			:      int     						=  SkipList()
						skip_list.delete('''Some key'''   )

						assert len(skip_list.head.forward   ) == 0





def        lowerCamelCase_      (  ) ->	List[str]:
						UpperCAmelCase_			:      Optional[Any]     						=  SkipList()

						skip_list.insert('''Key1''',			12   )
						skip_list.insert('''V''',			13   )
						skip_list.insert('''X''',			14   )
						skip_list.insert('''Key2''',			15   )

						skip_list.delete('''V'''   )
						skip_list.delete('''Key2'''   )

						assert skip_list.find('''V'''   ) is None
						assert skip_list.find('''Key2'''   ) is None





def        lowerCamelCase_      (  ) ->	Optional[Any]:
						UpperCAmelCase_			:      int     						=  SkipList()

						skip_list.insert('''Key1''',			12   )
						skip_list.insert('''V''',			13   )
						skip_list.insert('''X''',			14   )
						skip_list.insert('''Key2''',			15   )

						skip_list.delete('''V'''   )
						assert skip_list.find('''V'''   ) is None
						assert skip_list.find('''X'''   ) == 14
						assert skip_list.find('''Key1'''   ) == 12
						assert skip_list.find('''Key2'''   ) == 15

						skip_list.delete('''X'''   )
						assert skip_list.find('''V'''   ) is None
						assert skip_list.find('''X'''   ) is None
						assert skip_list.find('''Key1'''   ) == 12
						assert skip_list.find('''Key2'''   ) == 15

						skip_list.delete('''Key1'''   )
						assert skip_list.find('''V'''   ) is None
						assert skip_list.find('''X'''   ) is None
						assert skip_list.find('''Key1'''   ) is None
						assert skip_list.find('''Key2'''   ) == 15

						skip_list.delete('''Key2'''   )
						assert skip_list.find('''V'''   ) is None
						assert skip_list.find('''X'''   ) is None
						assert skip_list.find('''Key1'''   ) is None
						assert skip_list.find('''Key2'''   ) is None





def        lowerCamelCase_      (  ) ->	Tuple:
						UpperCAmelCase_			:      Tuple     						=  SkipList()

						skip_list.insert('''Key1''',			12   )
						skip_list.insert('''V''',			13   )
						skip_list.insert('''X''',			142   )
						skip_list.insert('''Key2''',			15   )

						skip_list.delete('''X'''   )

						def traverse_keys(SCREAMING_SNAKE_CASE__      :			Optional[Any]   ):
												yield node.key
												for forward_node in node.forward:
																		yield from traverse_keys(SCREAMING_SNAKE_CASE__   )

						assert len(set(traverse_keys(skip_list.head   )   )   ) == 4





def        lowerCamelCase_      (  ) ->	Union[str, Any]:
						def is_sorted(SCREAMING_SNAKE_CASE__      :			Tuple   ):
												return all(next_item >= item for item, next_item in zip(SCREAMING_SNAKE_CASE__,			lst[1:]   )   )

						UpperCAmelCase_			:      Union[str, Any]     						=  SkipList()
						for i in range(10   ):
												skip_list.insert(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   )
						assert is_sorted(list(SCREAMING_SNAKE_CASE__   )   )
						skip_list.delete(5   )
						skip_list.delete(8   )
						skip_list.delete(2   )
						assert is_sorted(list(SCREAMING_SNAKE_CASE__   )   )
						skip_list.insert(-12,			-12   )
						skip_list.insert(77,			77   )
						assert is_sorted(list(SCREAMING_SNAKE_CASE__   )   )





def        lowerCamelCase_      (  ) ->	Any:
						for _ in range(100   ):
												# Repeat test 100 times due to the probabilistic nature of skip list
												# random values == random bugs
												test_insert()
												test_insert_overrides_existing_value()

												test_searching_empty_list_returns_none()
												test_search()

												test_deleting_item_from_empty_list_do_nothing()
												test_deleted_items_are_not_founded_by_find_method()
												test_delete_removes_only_given_key()
												test_delete_doesnt_leave_dead_nodes()

												test_iter_always_yields_sorted_values()





def        lowerCamelCase_      (  ) ->	Any:
						UpperCAmelCase_			:      Dict     						=  SkipList()
						skip_list.insert(2,			'''2'''   )
						skip_list.insert(4,			'''4'''   )
						skip_list.insert(6,			'''4'''   )
						skip_list.insert(4,			'''5'''   )
						skip_list.insert(8,			'''4'''   )
						skip_list.insert(9,			'''4'''   )

						skip_list.delete(4   )

						print(SCREAMING_SNAKE_CASE__   )


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					main()












'''simple docstring'''







import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation


class 					__a      (unittest.TestCase     ):

							def     UpperCAmelCase__	(							self							:     Dict   )					->       Dict:







													"""simple docstring"""
													UpperCAmelCase_			:      Dict     						=  get_activation('''swish'''   )

													self.assertIsInstance(__magic_name__       ,     nn.SiLU   )

													self.assertEqual(act(torch.tensor(-1_00       ,     dtype=torch.floataa   )   ).item()       ,     0   )
													self.assertNotEqual(act(torch.tensor(-1       ,     dtype=torch.floataa   )   ).item()       ,     0   )
													self.assertEqual(act(torch.tensor(0       ,     dtype=torch.floataa   )   ).item()       ,     0   )
													self.assertEqual(act(torch.tensor(20       ,     dtype=torch.floataa   )   ).item()       ,     20   )

							def     UpperCAmelCase__	(							self							:     Tuple   )					->       Tuple:







													"""simple docstring"""
													UpperCAmelCase_			:      Union[str, Any]     						=  get_activation('''silu'''   )

													self.assertIsInstance(__magic_name__       ,     nn.SiLU   )

													self.assertEqual(act(torch.tensor(-1_00       ,     dtype=torch.floataa   )   ).item()       ,     0   )
													self.assertNotEqual(act(torch.tensor(-1       ,     dtype=torch.floataa   )   ).item()       ,     0   )
													self.assertEqual(act(torch.tensor(0       ,     dtype=torch.floataa   )   ).item()       ,     0   )
													self.assertEqual(act(torch.tensor(20       ,     dtype=torch.floataa   )   ).item()       ,     20   )

							def     UpperCAmelCase__	(							self							:     Tuple   )					->       Optional[int]:







													"""simple docstring"""
													UpperCAmelCase_			:      Optional[int]     						=  get_activation('''mish'''   )

													self.assertIsInstance(__magic_name__       ,     nn.Mish   )

													self.assertEqual(act(torch.tensor(-2_00       ,     dtype=torch.floataa   )   ).item()       ,     0   )
													self.assertNotEqual(act(torch.tensor(-1       ,     dtype=torch.floataa   )   ).item()       ,     0   )
													self.assertEqual(act(torch.tensor(0       ,     dtype=torch.floataa   )   ).item()       ,     0   )
													self.assertEqual(act(torch.tensor(20       ,     dtype=torch.floataa   )   ).item()       ,     20   )



							def     UpperCAmelCase__	(							self							:     str   )					->       Optional[Any]:







													"""simple docstring"""
													UpperCAmelCase_			:      List[Any]     						=  get_activation('''gelu'''   )

													self.assertIsInstance(__magic_name__       ,     nn.GELU   )

													self.assertEqual(act(torch.tensor(-1_00       ,     dtype=torch.floataa   )   ).item()       ,     0   )
													self.assertNotEqual(act(torch.tensor(-1       ,     dtype=torch.floataa   )   ).item()       ,     0   )
													self.assertEqual(act(torch.tensor(0       ,     dtype=torch.floataa   )   ).item()       ,     0   )
													self.assertEqual(act(torch.tensor(20       ,     dtype=torch.floataa   )   ).item()       ,     20   )





