


"""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 snake_case   (	lowercase_  ,					lowercase_  ,					unittest.TestCase):
		__UpperCamelCase							     =      UNetaDModel
		__UpperCamelCase							     =      """sample"""







		@property
		def 			a_			(       self   :							List[Any]		)							->    Any:





						'''simple docstring'''







						_A       	=      4
						_A       	=      14
						_A       	=      16

						_A       	=      floats_tensor((batch_size, num_features, seq_len)		).to(a__		)
						_A       	=      torch.tensor([10] * batch_size		).to(a__		)

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







		@property
		def 			a_			(       self   :							Dict		)							->    Optional[int]:





						'''simple docstring'''







						return (4, 14, 16)







		@property
		def 			a_			(       self   :							Optional[int]		)							->    int:





						'''simple docstring'''







						return (4, 14, 16)







		def 			a_			(       self   :							Optional[Any]		)							->    Optional[int]:





						'''simple docstring'''







						pass







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





						'''simple docstring'''







						pass







		@unittest.skipIf(torch_device == "mps"     , "mish op not supported in MPS"		)
		def 			a_			(       self   :							List[Any]		)							->    int:





						'''simple docstring'''







						super().test_determinism()







		@unittest.skipIf(torch_device == "mps"     , "mish op not supported in MPS"		)
		def 			a_			(       self   :							Optional[Any]		)							->    List[str]:





						'''simple docstring'''







						super().test_outputs_equivalence()







		@unittest.skipIf(torch_device == "mps"     , "mish op not supported in MPS"		)
		def 			a_			(       self   :							Union[str, Any]		)							->    List[Any]:





						'''simple docstring'''







						super().test_from_save_pretrained()







		@unittest.skipIf(torch_device == "mps"     , "mish op not supported in MPS"		)
		def 			a_			(       self   :							Optional[Any]		)							->    Optional[int]:





						'''simple docstring'''







						super().test_from_save_pretrained_variant()







		@unittest.skipIf(torch_device == "mps"     , "mish op not supported in MPS"		)
		def 			a_			(       self   :							List[str]		)							->    str:





						'''simple docstring'''







						super().test_model_from_pretrained()







		@unittest.skipIf(torch_device == "mps"     , "mish op not supported in MPS"		)
		def 			a_			(       self   :							List[str]		)							->    Tuple:





						'''simple docstring'''







						super().test_output()







		def 			a_			(       self   :							Optional[Any]		)							->    List[Any]:





						'''simple docstring'''







						_A       	=      {
						    "block_out_channels": (32, 64, 1_28, 2_56),
						    "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       	=      self.dummy_input
						return init_dict, inputs_dict







		@unittest.skipIf(torch_device == "mps"     , "mish op not supported in MPS"		)
		def 			a_			(       self   :							List[Any]		)							->    List[str]:





						'''simple docstring'''







						_A	,		_A       	=      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       	=      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 			a_			(       self   :							Dict		)							->    Union[str, Any]:





						'''simple docstring'''







						_A       	=      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       	=      model.config.in_channels
						_A       	=      16
						_A       	=      torch.randn((1, seq_len, num_features)		).permute(
						    0     , 2     , 1		)  # match original, we can update values and remove
						_A       	=      torch.full((num_features,)     , 0		)

						with torch.no_grad():
										_A       	=      model(a__     , a__		).sample.permute(0     , 2     , 1		)

						_A       	=      output[0, -3:, -3:].flatten()
						# fmt: off
						_A       	=      torch.tensor([-2.1_3_7_1_7_2, 1.1_4_2_6_0_1_6, 0.3_6_8_8_6_8_7, -0.7_6_6_9_2_2, 0.7_3_0_3_1_4_6, 0.1_1_0_3_8_8_6_4, -0.4_7_6_0_6_3_3, 0.1_3_2_7_0_1_7_2, 0.0_2_5_9_1_3_4_8]		)
						# fmt: on
						self.assertTrue(torch.allclose(a__     , a__     , rtol=1E-3		)		)







		def 			a_			(       self   :							Dict		)							->    int:





						'''simple docstring'''







						pass







		@slow
		def 			a_			(       self   :							str		)							->    Union[str, Any]:





						'''simple docstring'''







						_A       	=      "harmonai/maestro-150k"
						_A       	=      UNetaDModel.from_pretrained(a__     , subfolder="unet"		)
						model.to(a__		)

						_A       	=      6_55_36
						_A       	=      torch.sin(torch.arange(a__		)[None, None, :].repeat(1     , 2     , 1		)		).to(a__		)
						_A       	=      torch.tensor([1]		).to(a__		)

						with torch.no_grad():
										_A       	=      model(a__     , a__		).sample

						_A       	=      output.abs().sum()
						_A       	=      output.abs().max()

						assert (output_sum - 2_24.08_96).abs() < 0.5
						assert (output_max - 0.0_6_0_7).abs() < 4E-4





class snake_case   (	lowercase_  ,					lowercase_  ,					unittest.TestCase):
		__UpperCamelCase							     =      UNetaDModel
		__UpperCamelCase							     =      """sample"""







		@property
		def 			a_			(       self   :							Optional[int]		)							->    Optional[Any]:





						'''simple docstring'''







						_A       	=      4
						_A       	=      14
						_A       	=      16

						_A       	=      floats_tensor((batch_size, num_features, seq_len)		).to(a__		)
						_A       	=      torch.tensor([10] * batch_size		).to(a__		)

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







		@property
		def 			a_			(       self   :							Optional[int]		)							->    Dict:





						'''simple docstring'''







						return (4, 14, 16)







		@property
		def 			a_			(       self   :							Any		)							->    str:





						'''simple docstring'''







						return (4, 14, 1)







		@unittest.skipIf(torch_device == "mps"     , "mish op not supported in MPS"		)
		def 			a_			(       self   :							str		)							->    int:





						'''simple docstring'''







						super().test_determinism()







		@unittest.skipIf(torch_device == "mps"     , "mish op not supported in MPS"		)
		def 			a_			(       self   :							Union[str, Any]		)							->    List[str]:





						'''simple docstring'''







						super().test_outputs_equivalence()







		@unittest.skipIf(torch_device == "mps"     , "mish op not supported in MPS"		)
		def 			a_			(       self   :							Optional[int]		)							->    Dict:





						'''simple docstring'''







						super().test_from_save_pretrained()







		@unittest.skipIf(torch_device == "mps"     , "mish op not supported in MPS"		)
		def 			a_			(       self   :							Dict		)							->    Optional[Any]:





						'''simple docstring'''







						super().test_from_save_pretrained_variant()







		@unittest.skipIf(torch_device == "mps"     , "mish op not supported in MPS"		)
		def 			a_			(       self   :							Tuple		)							->    Optional[Any]:





						'''simple docstring'''







						super().test_model_from_pretrained()







		@unittest.skipIf(torch_device == "mps"     , "mish op not supported in MPS"		)
		def 			a_			(       self   :							Union[str, Any]		)							->    int:





						'''simple docstring'''







						_A	,		_A       	=      self.prepare_init_args_and_inputs_for_common()
						_A       	=      self.model_class(**a__		)
						model.to(a__		)
						model.eval()

						with torch.no_grad():
										_A       	=      model(**a__		)

										if isinstance(a__     , a__		):
														_A       	=      output.sample

						self.assertIsNotNone(a__		)
						_A       	=      torch.Size((inputs_dict["sample"].shape[0], 1)		)
						self.assertEqual(output.shape     , a__     , "Input and output shapes do not match"		)







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





						'''simple docstring'''







						pass







		def 			a_			(       self   :							Union[str, Any]		)							->    Optional[int]:





						'''simple docstring'''







						pass







		def 			a_			(       self   :							int		)							->    Any:





						'''simple docstring'''







						_A       	=      {
						    "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, 1_28, 2_56],
						    "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       	=      self.dummy_input
						return init_dict, inputs_dict







		@unittest.skipIf(torch_device == "mps"     , "mish op not supported in MPS"		)
		def 			a_			(       self   :							Dict		)							->    List[Any]:





						'''simple docstring'''







						_A	,		_A       	=      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       	=      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 			a_			(       self   :							Optional[int]		)							->    List[Any]:





						'''simple docstring'''







						_A	,		_A       	=      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       	=      value_function.config.in_channels
						_A       	=      14
						_A       	=      torch.randn((1, seq_len, num_features)		).permute(
						    0     , 2     , 1		)  # match original, we can update values and remove
						_A       	=      torch.full((num_features,)     , 0		)

						with torch.no_grad():
										_A       	=      value_function(a__     , a__		).sample

						# fmt: off
						_A       	=      torch.tensor([1_65.25] * seq_len		)
						# fmt: on
						self.assertTrue(torch.allclose(a__     , a__     , rtol=1E-3		)		)







		def 			a_			(       self   :							Union[str, Any]		)							->    int:





						'''simple docstring'''







						pass





"""simple docstring"""

from .chunk_utils import chunk_layer
from .data_transforms import make_atomaa_masks
from .feats import atomaa_to_atomaa, frames_and_literature_positions_to_atomaa_pos, torsion_angles_to_frames
from .loss import compute_predicted_aligned_error, compute_tm
from .protein import Protein as OFProtein
from .protein import to_pdb
from .rigid_utils import Rigid, Rotation
from .tensor_utils import dict_multimap, flatten_final_dims, permute_final_dims


