




import tempfile
import unittest

import numpy as np
import torch

from diffusers import DiffusionPipeline
from diffusers.models.attention_processor import Attention, AttnAddedKVProcessor

class   __a(     unittest.TestCase   ):






    """simple docstring"""





    def 							a__      (      self   ,_SCREAMING_SNAKE_CASE = False  ) ->		Dict:
         UpperCAmelCase_			:							Optional[int]   =			10

         if only_cross_attention:
              UpperCAmelCase_			:							List[Any]   =			12
         else:
              # when only cross attention is not set, the cross attention dim must be the same as the query dim
              UpperCAmelCase_			:							Optional[int]   =			query_dim

         return {
             "query_dim": query_dim,
             "cross_attention_dim": cross_attention_dim,
             "heads": 2,
             "dim_head": 4,
             "added_kv_proj_dim": 6,
             "norm_num_groups": 1,
             "only_cross_attention": only_cross_attention,
             "processor": AttnAddedKVProcessor(),
         }





    def 							a__      (      self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE  ) ->		List[str]:
         UpperCAmelCase_			:							Optional[Any]   =			2

         UpperCAmelCase_			:							str   =			torch.rand(a__   ,a__   ,3   ,2  )
         UpperCAmelCase_			:							int   =			torch.rand(a__   ,4   ,a__  )
         UpperCAmelCase_			:							int   =			None

         return {
             "hidden_states": hidden_states,
             "encoder_hidden_states": encoder_hidden_states,
             "attention_mask": attention_mask,
         }





    def 							a__      (      self  ) ->		Optional[int]:
         torch.manual_seed(0  )

         UpperCAmelCase_			:							List[Any]   =			self.get_constructor_arguments(only_cross_attention=a__  )
         UpperCAmelCase_			:							Tuple   =			Attention(**a__  )

         self.assertTrue(attn.to_k is not None  )
         self.assertTrue(attn.to_v is not None  )

         UpperCAmelCase_			:							List[Any]   =			self.get_forward_arguments(
             query_dim=constructor_args['''query_dim''']   ,added_kv_proj_dim=constructor_args['''added_kv_proj_dim''']  )

         UpperCAmelCase_			:							Dict   =			attn(**a__  )

         # only self attention

         torch.manual_seed(0  )

         UpperCAmelCase_			:							Any   =			self.get_constructor_arguments(only_cross_attention=a__  )
         UpperCAmelCase_			:							Any   =			Attention(**a__  )

         self.assertTrue(attn.to_k is None  )
         self.assertTrue(attn.to_v is None  )

         UpperCAmelCase_			:							Tuple   =			self.get_forward_arguments(
             query_dim=constructor_args['''query_dim''']   ,added_kv_proj_dim=constructor_args['''added_kv_proj_dim''']  )

         UpperCAmelCase_			:							Optional[Any]   =			attn(**a__  )

         self.assertTrue((only_cross_attn_out != self_and_cross_attn_out).all()  )


class   __a(     unittest.TestCase   ):






    """simple docstring"""





    def 							a__      (      self  ) ->		Optional[int]:
         UpperCAmelCase_			:							str   =			DiffusionPipeline.from_pretrained('''hf-internal-testing/tiny-stable-diffusion-pipe'''   ,safety_checker=a__  )

         UpperCAmelCase_			:							Optional[Any]   =			pipe(
             '''foo'''   ,num_inference_steps=2   ,generator=torch.Generator('''cpu'''  ).manual_seed(0  )   ,output_type='''np'''   ,).images

         # the initial conversion succeeds
         UpperCAmelCase_			:							int   =			DiffusionPipeline.from_pretrained(
             '''hf-internal-testing/tiny-stable-diffusion-pipe'''   ,device_map='''sequential'''   ,safety_checker=a__  )

         UpperCAmelCase_			:							Union[str, Any]   =			pipe(
             '''foo'''   ,num_inference_steps=2   ,generator=torch.Generator('''cpu'''  ).manual_seed(0  )   ,output_type='''np'''   ,).images

         with tempfile.TemporaryDirectory() as tmpdir:
              # save the converted model
              pipe.save_pretrained(a__  )

              # can also load the converted weights
              UpperCAmelCase_			:							Dict   =			DiffusionPipeline.from_pretrained(a__   ,device_map='''sequential'''   ,safety_checker=a__  )

         UpperCAmelCase_			:							Dict   =			pipe(
             '''foo'''   ,num_inference_steps=2   ,generator=torch.Generator('''cpu'''  ).manual_seed(0  )   ,output_type='''np'''   ,).images

         self.assertTrue(np.allclose(a__   ,a__   ,atol=1e-5  )  )
         self.assertTrue(np.allclose(a__   ,a__   ,atol=1e-5  )  )



"""simple docstring"""


from __future__ import annotations

a_											=			[2, 1, 4, 5, 6, 0, 8, 9, 1, 2, 0, 6, 4, 2, 0, 6, 5, 3, 2, 7]
class snake_case					:







		def __init__(    self					:				Optional[int]			,      a__					:				int						)				->  None:





						'''simple docstring'''







						_A         =	-1
						_A         =	-1
						_A         =	[-1] * length
						_A         =	None
						_A         =	None







		def __repr__(    self					:				Any						)				->  str:





						'''simple docstring'''







						return F"""Node(min_value={self.minn} max_value={self.maxx})"""






def    a__       ( __lowercase      )		->		Node | None:
				_A         =	Node(len(__lowercase      )      )
				_A     ,						_A         =	min(__lowercase      ), max(__lowercase      )
				# Leaf node case where the node contains only one unique value
				if root.minn == root.maxx:
								return root
				_A         =	(root.minn + root.maxx) // 2

				_A         =	[]
				_A         =	[]

				for index, num in enumerate(__lowercase      ):
								if num <= pivot:
												left_arr.append(__lowercase      )
								else:
												right_arr.append(__lowercase      )
								_A         =	len(__lowercase      )
				_A         =	build_tree(__lowercase      )
				_A         =	build_tree(__lowercase      )
				return root






def    a__       ( __lowercase   ,	__lowercase   ,	__lowercase      )		->		int:
				if index < 0 or node is None:
								return 0
				# Leaf node cases
				if node.minn == node.maxx:
								return index + 1 if node.minn == num else 0
				_A         =	(node.minn + node.maxx) // 2
				if num <= pivot:
								# go the left subtree and map index to the left subtree
								return rank_till_index(node.left   ,	__lowercase   ,	node.map_left[index] - 1      )
				else:
								# go to the right subtree and map index to the right subtree
								return rank_till_index(node.right   ,	__lowercase   ,	index - node.map_left[index]      )






def    a__       ( __lowercase   ,	__lowercase   ,	__lowercase   ,	__lowercase      )		->		int:
				if start > end:
								return 0
				_A         =	rank_till_index(__lowercase   ,	__lowercase   ,	__lowercase      )
				_A         =	rank_till_index(__lowercase   ,	__lowercase   ,	start - 1      )
				return rank_till_end - rank_before_start






def    a__       ( __lowercase   ,	__lowercase   ,	__lowercase   ,	__lowercase      )		->		int:
				if index > (end - start) or start > end or node is None:
								return -1
				# Leaf node case
				if node.minn == node.maxx:
								return node.minn
				# Number of elements in the left subtree in interval [start, end]
				_A         =	node.map_left[end] - (
				    node.map_left[start - 1] if start else 0
				)
				if num_elements_in_left_tree > index:
								return quantile(
								    node.left   ,	__lowercase   ,	(node.map_left[start - 1] if start else 0)   ,	node.map_left[end] - 1   ,	)
				else:
								return quantile(
								    node.right   ,	index - num_elements_in_left_tree   ,	start - (node.map_left[start - 1] if start else 0)   ,	end - node.map_left[end]   ,	)






def    a__       ( __lowercase   ,	__lowercase   ,	__lowercase   ,	__lowercase   ,	__lowercase      )		->		int:
				if (
				    start > end
				    or node is None
				    or start_num > end_num
				    or node.minn > end_num
				    or node.maxx < start_num
				):
								return 0
				if start_num <= node.minn and node.maxx <= end_num:
								return end - start + 1
				_A         =	range_counting(
				    node.left   ,	(node.map_left[start - 1] if start else 0)   ,	node.map_left[end] - 1   ,	__lowercase   ,	__lowercase   ,	)
				_A         =	range_counting(
				    node.right   ,	start - (node.map_left[start - 1] if start else 0)   ,	end - node.map_left[end]   ,	__lowercase   ,	__lowercase   ,	)
				return left + right


if __name__ == "__main__":
		import doctest

		doctest.testmod()