


'''simple docstring'''



from __future__ import annotations






def 						lowerCamelCase							(_SCREAMING_SNAKE_CASE   :     list[int]		,   _SCREAMING_SNAKE_CASE   :     int     ):
					__a					,       __a    : Union[str, Any]      					=						0, len(_SCREAMING_SNAKE_CASE     ) - 1
					while start_ind <= end_ind:
										if array[start_ind] == search_item:
															return start_ind
										elif array[end_ind] == search_item:
															return end_ind
										else:
															start_ind += 1
															end_ind -= 1
    # returns -1 if search_item is not found in array
					return -1


if __name__ == "__main__":
	print(double_linear_search(list(range(1_00)), 40))







'''simple docstring'''



import unittest

import torch

from diffusers import UNetaDModel
from diffusers.utils import floats_tensor, slow, torch_device

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin





class 							__UpperCamelCase       (	lowerCAmelCase_	,   lowerCAmelCase_	,   unittest.TestCase      ):
	A_			    =					UNetaDModel
	A_			    =					"sample"




	@property
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a    : List[str]      					=						4
						__a    : str      					=						14
						__a    : int      					=						16

						__a    : List[str]      					=						floats_tensor((batch_size, num_features, seq_len)							).to(__a							)
						__a    : Optional[Any]      					=						torch.tensor([10] * batch_size							).to(__a							)

						return {"sample": noise, "timestep": time_step}




	@property
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						return (4, 14, 16)




	@property
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						return (4, 14, 16)




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						pass




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						pass




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						super().test_determinism()




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						super().test_outputs_equivalence()




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						super().test_from_save_pretrained()




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						super().test_from_save_pretrained_variant()




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						super().test_model_from_pretrained()




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						super().test_output()




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a    : Union[str, Any]      					=						{
						    'block_out_channels': (32, 64, 128, 256),
						    'in_channels': 14,
						    'out_channels': 14,
						    'time_embedding_type': 'positional',
						    'use_timestep_embedding': True,
						    'flip_sin_to_cos': False,
						    'freq_shift': 1.0,
						    'out_block_type': 'OutConv1DBlock',
						    'mid_block_type': 'MidResTemporalBlock1D',
						    'down_block_types': ('DownResnetBlock1D', 'DownResnetBlock1D', 'DownResnetBlock1D', 'DownResnetBlock1D'),
						    'up_block_types': ('UpResnetBlock1D', 'UpResnetBlock1D', 'UpResnetBlock1D'),
						    'act_fn': 'mish',
						}
						__a    : str      					=						self.dummy_input
						return init_dict, inputs_dict




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a					,       __a    : List[str]      					=						UNetaDModel.from_pretrained(
						    'bglick13/hopper-medium-v2-value-function-hor32'		,       output_loading_info=__a		,       subfolder='unet'							)
						self.assertIsNotNone(__a							)
						self.assertEqual(len(loading_info['missing_keys']							)		,       0							)

						model.to(__a							)
						__a    : Optional[int]      					=						model(**self.dummy_input							)

						assert image is not None, "Make sure output is not None"




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a    : List[Any]      					=						UNetaDModel.from_pretrained('bglick13/hopper-medium-v2-value-function-hor32'		,       subfolder='unet'							)
						torch.manual_seed(0							)
						if torch.cuda.is_available():
											torch.cuda.manual_seed_all(0							)

						__a    : str      					=						model.config.in_channels
						__a    : int      					=						16
						__a    : List[str]      					=						torch.randn((1, seq_len, num_features)							).permute(
						    0		,       2		,       1							)  # match original, we can update values and remove
						__a    : List[Any]      					=						torch.full((num_features,)		,       0							)

						with torch.no_grad():
											__a    : Tuple      					=						model(__a		,       __a							).sample.permute(0		,       2		,       1							)

						__a    : int      					=						output[0, -3:, -3:].flatten()
						# fmt: off
						__a    : List[str]      					=						torch.tensor([-2.137172, 1.1426016, 0.3688687, -0.766922, 0.7303146, 0.11038864, -0.4760633, 0.13270172, 0.02591348]							)
						# fmt: on
						self.assertTrue(torch.allclose(__a		,       __a		,       rtol=1E-3							)							)




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						pass





	@slow
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a    : Tuple      					=						'harmonai/maestro-150k'
						__a    : Any      					=						UNetaDModel.from_pretrained(__a		,       subfolder='unet'							)
						model.to(__a							)

						__a    : Optional[Any]      					=						6_5536
						__a    : str      					=						torch.sin(torch.arange(__a							)[None, None, :].repeat(1		,       2		,       1							)							).to(__a							)
						__a    : int      					=						torch.tensor([1]							).to(__a							)

						with torch.no_grad():
											__a    : Optional[int]      					=						model(__a		,       __a							).sample

						__a    : Union[str, Any]      					=						output.abs().sum()
						__a    : Dict      					=						output.abs().max()

						assert (output_sum - 224.0896).abs() < 0.5
						assert (output_max - 0.0607).abs() < 4E-4





class 							__UpperCamelCase       (	lowerCAmelCase_	,   lowerCAmelCase_	,   unittest.TestCase      ):
	A_			    =					UNetaDModel
	A_			    =					"sample"




	@property
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a    : str      					=						4
						__a    : str      					=						14
						__a    : Optional[int]      					=						16

						__a    : str      					=						floats_tensor((batch_size, num_features, seq_len)							).to(__a							)
						__a    : Optional[Any]      					=						torch.tensor([10] * batch_size							).to(__a							)

						return {"sample": noise, "timestep": time_step}




	@property
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						return (4, 14, 16)




	@property
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						return (4, 14, 1)




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						super().test_determinism()




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						super().test_outputs_equivalence()




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						super().test_from_save_pretrained()




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						super().test_from_save_pretrained_variant()




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						super().test_model_from_pretrained()




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a					,       __a    : List[Any]      					=						self.prepare_init_args_and_inputs_for_common()
						__a    : int      					=						self.model_class(**__a							)
						model.to(__a							)
						model.eval()

						with torch.no_grad():
											__a    : Optional[Any]      					=						model(**__a							)

											if isinstance(__a		,       __a							):
																__a    : Any      					=						output.sample

						self.assertIsNotNone(__a							)
						__a    : Tuple      					=						torch.Size((inputs_dict['sample'].shape[0], 1)							)
						self.assertEqual(output.shape		,       __a		,       'Input and output shapes do not match'							)




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						pass




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						pass




	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a    : int      					=						{
						    'in_channels': 14,
						    'out_channels': 14,
						    'down_block_types': ['DownResnetBlock1D', 'DownResnetBlock1D', 'DownResnetBlock1D', 'DownResnetBlock1D'],
						    'up_block_types': [],
						    'out_block_type': 'ValueFunction',
						    'mid_block_type': 'ValueFunctionMidBlock1D',
						    'block_out_channels': [32, 64, 128, 256],
						    'layers_per_block': 1,
						    'downsample_each_block': True,
						    'use_timestep_embedding': True,
						    'freq_shift': 1.0,
						    'flip_sin_to_cos': False,
						    'time_embedding_type': 'positional',
						    'act_fn': 'mish',
						}
						__a    : Union[str, Any]      					=						self.dummy_input
						return init_dict, inputs_dict




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a					,       __a    : List[str]      					=						UNetaDModel.from_pretrained(
						    'bglick13/hopper-medium-v2-value-function-hor32'		,       output_loading_info=__a		,       subfolder='value_function'							)
						self.assertIsNotNone(__a							)
						self.assertEqual(len(vf_loading_info['missing_keys']							)		,       0							)

						value_function.to(__a							)
						__a    : Optional[Any]      					=						value_function(**self.dummy_input							)

						assert image is not None, "Make sure output is not None"




	@unittest.skipIf(torch_device == 'mps'		,       'mish op not supported in MPS'							)
	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						__a					,       __a    : Dict      					=						UNetaDModel.from_pretrained(
						    'bglick13/hopper-medium-v2-value-function-hor32'		,       output_loading_info=__a		,       subfolder='value_function'							)
						torch.manual_seed(0							)
						if torch.cuda.is_available():
											torch.cuda.manual_seed_all(0							)

						__a    : str      					=						value_function.config.in_channels
						__a    : Dict      					=						14
						__a    : List[str]      					=						torch.randn((1, seq_len, num_features)							).permute(
						    0		,       2		,       1							)  # match original, we can update values and remove
						__a    : List[Any]      					=						torch.full((num_features,)		,       0							)

						with torch.no_grad():
											__a    : Any      					=						value_function(__a		,       __a							).sample

						# fmt: off
						__a    : str      					=						torch.tensor([165.25] * seq_len							)
						# fmt: on
						self.assertTrue(torch.allclose(__a		,       __a		,       rtol=1E-3							)							)





	def    __UpperCAmelCase							(     self							):

						'''simple docstring'''





						pass



