


'''simple docstring'''


import unittest
from typing import Tuple

import torch

from diffusers.utils import floats_tensor, randn_tensor, torch_all_close, torch_device
from diffusers.utils.testing_utils import require_torch





@require_torch
class     lowercase__  :





							'''simple docstring'''


							@property
							def UpperCAmelCase_	(    self  ):
											return self.get_dummy_input()






							@property
							def UpperCAmelCase_	(    self  ):
											if self.block_type == "down":
															return (4, 32, 16, 16)
											elif self.block_type == "mid":
															return (4, 32, 32, 32)
											elif self.block_type == "up":
															return (4, 32, 64, 64)

											raise ValueError(f"""'{self.block_type}' is not a supported block_type. Set it to 'up', 'mid', or 'down'."""  )






							def UpperCAmelCase_	(    self    ,					__snake_case=True    ,					__snake_case=False    ,					__snake_case=False    ,					__snake_case=False    ,					):
											_SCREAMING_SNAKE_CASE :       List[str]     		=      4
											_SCREAMING_SNAKE_CASE :       Tuple     		=      32
											_SCREAMING_SNAKE_CASE :       Tuple     		=      (32, 32)

											_SCREAMING_SNAKE_CASE :       str     		=      torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE :       Optional[int]     		=      torch.device(__snake_case  )
											_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      (batch_size, num_channels) + sizes
											_SCREAMING_SNAKE_CASE :       Any     		=      randn_tensor(__snake_case    ,					generator=__snake_case    ,					device=__snake_case  )
											_SCREAMING_SNAKE_CASE :       Any     		=      {"""hidden_states""": hidden_states}

											if include_temb:
															_SCREAMING_SNAKE_CASE :       Optional[int]     		=      128
															_SCREAMING_SNAKE_CASE :       Optional[int]     		=      randn_tensor((batch_size, temb_channels)    ,					generator=__snake_case    ,					device=__snake_case  )

											if include_res_hidden_states_tuple:
															_SCREAMING_SNAKE_CASE :       Tuple     		=      torch.manual_seed(1  )
															_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      (randn_tensor(__snake_case    ,					generator=__snake_case    ,					device=__snake_case  ),)

											if include_encoder_hidden_states:
															_SCREAMING_SNAKE_CASE :       Dict     		=      floats_tensor((batch_size, 32, 32)  ).to(__snake_case  )

											if include_skip_sample:
															_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      randn_tensor(((batch_size, 3) + sizes)    ,					generator=__snake_case    ,					device=__snake_case  )

											return dummy_input






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE :       Dict     		=      {
											    """in_channels""": 32,
											    """out_channels""": 32,
											    """temb_channels""": 128,
											}
											if self.block_type == "up":
															_SCREAMING_SNAKE_CASE :       List[Any]     		=      32

											if self.block_type == "mid":
															init_dict.pop("""out_channels"""  )

											_SCREAMING_SNAKE_CASE :       List[Any]     		=      self.dummy_input
											return init_dict, inputs_dict






							def UpperCAmelCase_	(    self    ,					__snake_case  ):
											_SCREAMING_SNAKE_CASE		,       _SCREAMING_SNAKE_CASE :       Optional[Any]     		=      self.prepare_init_args_and_inputs_for_common()
											_SCREAMING_SNAKE_CASE :       Any     		=      self.block_class(**__snake_case  )
											unet_block.to(__snake_case  )
											unet_block.eval()

											with torch.no_grad():
															_SCREAMING_SNAKE_CASE :       Tuple     		=      unet_block(**__snake_case  )

											if isinstance(__snake_case    ,					__snake_case  ):
															_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      output[0]

											self.assertEqual(output.shape    ,					self.output_shape  )

											_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      output[0, -1, -3:, -3:]
											_SCREAMING_SNAKE_CASE :       Tuple     		=      torch.tensor(__snake_case  ).to(__snake_case  )
											assert torch_all_close(output_slice.flatten()    ,					__snake_case    ,					atol=5e-3  )






							@unittest.skipIf(torch_device == """mps"""    ,					"""Training is not supported in mps"""  )
							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE		,       _SCREAMING_SNAKE_CASE :       str     		=      self.prepare_init_args_and_inputs_for_common()
											_SCREAMING_SNAKE_CASE :       Tuple     		=      self.block_class(**__snake_case  )
											model.to(__snake_case  )
											model.train()
											_SCREAMING_SNAKE_CASE :       List[str]     		=      model(**__snake_case  )

											if isinstance(__snake_case    ,					__snake_case  ):
															_SCREAMING_SNAKE_CASE :       List[Any]     		=      output[0]

											_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      torch.device(__snake_case  )
											_SCREAMING_SNAKE_CASE :       Tuple     		=      randn_tensor(output.shape    ,					device=__snake_case  )
											_SCREAMING_SNAKE_CASE :       Dict     		=      torch.nn.functional.mse_loss(__snake_case    ,					__snake_case  )
											loss.backward()








'''simple docstring'''


from typing import Dict

import numpy as np
import torch

from . import residue_constants as rc
from .tensor_utils import tensor_tree_map, tree_map







def 			snake_case_   (  SCREAMING_SNAKE_CASE__     ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE :       Tuple     		=      []
				_SCREAMING_SNAKE_CASE :       Dict     		=      []
				_SCREAMING_SNAKE_CASE :       str     		=      []

				for rt in rc.restypes:
								_SCREAMING_SNAKE_CASE :       Optional[int]     		=      rc.restype_name_to_atomaa_names[rc.restype_atoa[rt]]
								restype_atomaa_to_atomaa_list.append([(rc.atom_order[name] if name else 0) for name in atom_names]     )
								_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      {name: i for i, name in enumerate(SCREAMING_SNAKE_CASE__     )}
								restype_atomaa_to_atomaa_list.append(
								    [(atom_name_to_idxaa[name] if name in atom_name_to_idxaa else 0) for name in rc.atom_types]     )

								restype_atomaa_mask_list.append([(1.0 if name else 0.0) for name in atom_names]     )

				# Add dummy mapping for restype 'UNK'
				restype_atomaa_to_atomaa_list.append([0] * 14     )
				restype_atomaa_to_atomaa_list.append([0] * 37     )
				restype_atomaa_mask_list.append([0.0] * 14     )

				_SCREAMING_SNAKE_CASE :       Dict     		=      torch.tensor(
				    SCREAMING_SNAKE_CASE__							,      dtype=torch.intaa							,      device=protein["""aatype"""].device							,      )
				_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      torch.tensor(
				    SCREAMING_SNAKE_CASE__							,      dtype=torch.intaa							,      device=protein["""aatype"""].device							,      )
				_SCREAMING_SNAKE_CASE :       str     		=      torch.tensor(
				    SCREAMING_SNAKE_CASE__							,      dtype=torch.floataa							,      device=protein["""aatype"""].device							,      )
				_SCREAMING_SNAKE_CASE :       int     		=      protein["""aatype"""].to(torch.long     )

				# create the mapping for (residx, atom14) --> atom37, i.e. an array
				# with shape (num_res, 14) containing the atom37 indices for this protein
				_SCREAMING_SNAKE_CASE :       List[str]     		=      restype_atomaa_to_atomaa[protein_aatype]
				_SCREAMING_SNAKE_CASE :       str     		=      restype_atomaa_mask[protein_aatype]

				_SCREAMING_SNAKE_CASE :       List[Any]     		=      residx_atomaa_mask
				_SCREAMING_SNAKE_CASE :       List[str]     		=      residx_atomaa_to_atomaa.long()

				# create the gather indices for mapping back
				_SCREAMING_SNAKE_CASE :       int     		=      restype_atomaa_to_atomaa[protein_aatype]
				_SCREAMING_SNAKE_CASE :       Dict     		=      residx_atomaa_to_atomaa.long()

				# create the corresponding mask
				_SCREAMING_SNAKE_CASE :       str     		=      torch.zeros([21, 37]							,      dtype=torch.floataa							,      device=protein["""aatype"""].device     )
				for restype, restype_letter in enumerate(rc.restypes     ):
								_SCREAMING_SNAKE_CASE :       int     		=      rc.restype_atoa[restype_letter]
								_SCREAMING_SNAKE_CASE :       Dict     		=      rc.residue_atoms[restype_name]
								for atom_name in atom_names:
												_SCREAMING_SNAKE_CASE :       List[Any]     		=      rc.atom_order[atom_name]
												_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      1

				_SCREAMING_SNAKE_CASE :       int     		=      restype_atomaa_mask[protein_aatype]
				_SCREAMING_SNAKE_CASE :       int     		=      residx_atomaa_mask

				return protein







def 			snake_case_   (  SCREAMING_SNAKE_CASE__     ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      tree_map(lambda SCREAMING_SNAKE_CASE__     : torch.tensor(SCREAMING_SNAKE_CASE__							,      device=batch["""aatype"""].device     )							,      SCREAMING_SNAKE_CASE__							,      np.ndarray     )
				_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      tensor_tree_map(lambda SCREAMING_SNAKE_CASE__     : np.array(SCREAMING_SNAKE_CASE__     )							,      make_atomaa_masks(SCREAMING_SNAKE_CASE__     )     )
				return out




