




from typing import Dict, Tuple, overload

import torch
import torch.types
from torch import nn

from . import residue_constants as rc
from .rigid_utils import Rigid, Rotation
from .tensor_utils import batched_gather







@overload
def lowerCamelCase__   (			_lowercase ,						_lowercase ,						_lowercase      ):

     '''simple docstring'''


     ...







@overload
def lowerCamelCase__   (			_lowercase ,						_lowercase ,						_lowercase      ):

     '''simple docstring'''


     ...







def lowerCamelCase__   (			_lowercase ,						_lowercase ,						_lowercase      ):

     '''simple docstring'''


     UpperCAmelCase_			:							List[Any]   =			aatype == rc.restype_order['''G''']
     UpperCAmelCase_			:							List[str]   =			rc.atom_order['''CA''']
     UpperCAmelCase_			:							int   =			rc.atom_order['''CB''']
     UpperCAmelCase_			:							str   =			torch.where(
         is_gly[..., None].expand(*((-1,) * len(is_gly.shape      )) ,						3      ) ,						all_atom_positions[..., ca_idx, :] ,						all_atom_positions[..., cb_idx, :] ,						)

     if all_atom_masks is not None:
          UpperCAmelCase_			:							List[Any]   =			torch.where(
              lowercase_ ,						all_atom_masks[..., ca_idx] ,						all_atom_masks[..., cb_idx] ,						)
          return pseudo_beta, pseudo_beta_mask
     else:
          return pseudo_beta







def lowerCamelCase__   (			_lowercase ,						_lowercase      ):

     '''simple docstring'''


     UpperCAmelCase_			:							int   =			batched_gather(
         lowercase_ ,						batch['''residx_atom37_to_atom14'''] ,						dim=-2 ,						no_batch_dims=len(atomaa.shape[:-2]      ) ,						)

     UpperCAmelCase_			:							List[str]   =			atomaa_data * batch['''atom37_atom_exists'''][..., None]

     return atomaa_data







def lowerCamelCase__   (			_lowercase      ):

     '''simple docstring'''


     UpperCAmelCase_			:							Any   =			template_feats['''template_aatype''']
     UpperCAmelCase_			:							Tuple   =			template_feats['''template_torsion_angles_sin_cos''']
     UpperCAmelCase_			:							Tuple   =			template_feats['''template_alt_torsion_angles_sin_cos''']
     UpperCAmelCase_			:							str   =			template_feats['''template_torsion_angles_mask''']
     UpperCAmelCase_			:							Tuple   =			torch.cat(
         [
             nn.functional.one_hot(lowercase_ ,						22      ),
             torsion_angles_sin_cos.reshape(*torsion_angles_sin_cos.shape[:-2] ,						14      ),
             alt_torsion_angles_sin_cos.reshape(*alt_torsion_angles_sin_cos.shape[:-2] ,						14      ),
             torsion_angles_mask,
         ] ,						dim=-1 ,						)

     return template_angle_feat







def lowerCamelCase__   (			_lowercase ,						_lowercase ,						_lowercase ,						_lowercase ,						_lowercase = False ,						_lowercase = 1E-2_0 ,						_lowercase = 1E8 ,						):

     '''simple docstring'''


     UpperCAmelCase_			:							List[Any]   =			batch['''template_pseudo_beta_mask''']
     UpperCAmelCase_			:							Dict   =			template_mask[..., None] * template_mask[..., None, :]

     # Compute distogram (this seems to differ slightly from Alg. 5)
     UpperCAmelCase_			:							Optional[int]   =			batch['''template_pseudo_beta''']
     UpperCAmelCase_			:							Optional[Any]   =			torch.sum((tpb[..., None, :] - tpb[..., None, :, :]) ** 2 ,						dim=-1 ,						keepdim=lowercase_      )
     UpperCAmelCase_			:							Dict   =			torch.linspace(lowercase_ ,						lowercase_ ,						lowercase_ ,						device=tpb.device      ) ** 2
     UpperCAmelCase_			:							str   =			torch.cat([lower[1:], lower.new_tensor([inf]      )] ,						dim=-1      )
     UpperCAmelCase_			:							Union[str, Any]   =			((dgram > lower) * (dgram < upper)).type(dgram.dtype      )

     UpperCAmelCase_			:							Union[str, Any]   =			[dgram, template_mask_ad[..., None]]

     UpperCAmelCase_			:							Dict   =			nn.functional.one_hot(
         batch['''template_aatype'''] ,						rc.restype_num + 2 ,						)

     UpperCAmelCase_			:							Tuple   =			batch['''template_aatype'''].shape[-1]
     to_concat.append(aatype_one_hot[..., None, :, :].expand(*aatype_one_hot.shape[:-2] ,						lowercase_ ,						-1 ,						-1      )      )
     to_concat.append(aatype_one_hot[..., None, :].expand(*aatype_one_hot.shape[:-2] ,						-1 ,						lowercase_ ,						-1      )      )

     UpperCAmelCase_,    UpperCAmelCase_,    UpperCAmelCase_			:							str   =			[rc.atom_order[a] for a in ['''N''', '''CA''', '''C''']]
     UpperCAmelCase_			:							Optional[int]   =			Rigid.make_transform_from_reference(
         n_xyz=batch['''template_all_atom_positions'''][..., n, :] ,						ca_xyz=batch['''template_all_atom_positions'''][..., ca, :] ,						c_xyz=batch['''template_all_atom_positions'''][..., c, :] ,						eps=lowercase_ ,						)
     UpperCAmelCase_			:							Tuple   =			rigids.get_trans()[..., None, :, :]
     UpperCAmelCase_			:							Any   =			rigids[..., None].invert_apply(lowercase_      )

     UpperCAmelCase_			:							int   =			torch.rsqrt(eps + torch.sum(rigid_vec**2 ,						dim=-1      )      )

     UpperCAmelCase_			:							Any   =			batch['''template_all_atom_mask''']
     UpperCAmelCase_			:							str   =			t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
     UpperCAmelCase_			:							Dict   =			template_mask[..., None] * template_mask[..., None, :]

     UpperCAmelCase_			:							int   =			inv_distance_scalar * template_mask_ad
     UpperCAmelCase_			:							Union[str, Any]   =			rigid_vec * inv_distance_scalar[..., None]

     if not use_unit_vector:
          UpperCAmelCase_			:							Tuple   =			unit_vector * 0.0

     to_concat.extend(torch.unbind(unit_vector[..., None, :] ,						dim=-1      )      )
     to_concat.append(template_mask_ad[..., None]      )

     UpperCAmelCase_			:							Union[str, Any]   =			torch.cat(lowercase_ ,						dim=-1      )
     UpperCAmelCase_			:							Optional[Any]   =			act * template_mask_ad[..., None]

     return act







def lowerCamelCase__   (			_lowercase      ):

     '''simple docstring'''


     UpperCAmelCase_			:							Optional[Any]   =			nn.functional.one_hot(batch['''extra_msa'''] ,						23      )
     UpperCAmelCase_			:							List[str]   =			[
         msa_ahot,
         batch['''extra_has_deletion'''].unsqueeze(-1      ),
         batch['''extra_deletion_value'''].unsqueeze(-1      ),
     ]
     return torch.cat(lowercase_ ,						dim=-1      )







def lowerCamelCase__   (			_lowercase ,						_lowercase ,						_lowercase ,						_lowercase ,						):

     '''simple docstring'''


     UpperCAmelCase_			:							Tuple   =			rrgdf[aatype, ...]

     # [*, N, 8] transformations, i.e.
     #   One [*, N, 8, 3, 3] rotation matrix and
     #   One [*, N, 8, 3]    translation matrix
     UpperCAmelCase_			:							Tuple   =			r.from_tensor_axa(lowercase_      )

     UpperCAmelCase_			:							Union[str, Any]   =			alpha.new_zeros((*((1,) * len(alpha.shape[:-1]      )), 2)      )
     UpperCAmelCase_			:							str   =			1

     # [*, N, 8, 2]
     UpperCAmelCase_			:							str   =			torch.cat([bb_rot.expand(*alpha.shape[:-2] ,						-1 ,						-1      ), alpha] ,						dim=-2      )

     # [*, N, 8, 3, 3]
     # Produces rotation matrices of the form:
     # [
     #   [1, 0  , 0  ],
     #   [0, a_2,-a_1],
     #   [0, a_1, a_2]
     # ]
     # This follows the original code rather than the supplement, which uses
     # different indices.

     UpperCAmelCase_			:							List[Any]   =			alpha.new_zeros(default_r.get_rots().get_rot_mats().shape      )
     UpperCAmelCase_			:							List[Any]   =			1
     UpperCAmelCase_			:							Optional[int]   =			alpha[..., 1]
     UpperCAmelCase_			:							Dict   =			-alpha[..., 0]
     UpperCAmelCase_			:							Any   =			alpha

     UpperCAmelCase_			:							Tuple   =			default_r.compose(Rigid(Rotation(rot_mats=lowercase_      ) ,						lowercase_      )      )

     UpperCAmelCase_			:							Any   =			all_frames[..., 5]
     UpperCAmelCase_			:							Tuple   =			all_frames[..., 6]
     UpperCAmelCase_			:							Union[str, Any]   =			all_frames[..., 7]

     UpperCAmelCase_			:							int   =			all_frames[..., 4]
     UpperCAmelCase_			:							List[str]   =			chia_frame_to_bb.compose(lowercase_      )
     UpperCAmelCase_			:							Optional[Any]   =			chia_frame_to_bb.compose(lowercase_      )
     UpperCAmelCase_			:							List[Any]   =			chia_frame_to_bb.compose(lowercase_      )

     UpperCAmelCase_			:							Union[str, Any]   =			Rigid.cat(
         [
             all_frames[..., :5],
             chia_frame_to_bb.unsqueeze(-1      ),
             chia_frame_to_bb.unsqueeze(-1      ),
             chia_frame_to_bb.unsqueeze(-1      ),
         ] ,						dim=-1 ,						)

     UpperCAmelCase_			:							Tuple   =			r[..., None].compose(lowercase_      )

     return all_frames_to_global







def lowerCamelCase__   (			_lowercase ,						_lowercase ,						_lowercase ,						_lowercase ,						_lowercase ,						_lowercase ,						):

     '''simple docstring'''


     UpperCAmelCase_			:							Tuple   =			group_idx[aatype, ...]

     # [*, N, 14, 8]
     UpperCAmelCase_			:							str   =			nn.functional.one_hot(
         lowercase_ ,						num_classes=default_frames.shape[-3] ,						)

     # [*, N, 14, 8]
     UpperCAmelCase_			:							List[str]   =			r[..., None, :] * group_mask_one_hot

     # [*, N, 14]
     UpperCAmelCase_			:							str   =			t_atoms_to_global.map_tensor_fn(lambda _lowercase      : torch.sum(lowercase_ ,						dim=-1      )      )

     # [*, N, 14, 1]
     UpperCAmelCase_			:							Optional[int]   =			atom_mask[aatype, ...].unsqueeze(-1      )

     # [*, N, 14, 3]
     UpperCAmelCase_			:							int   =			lit_positions[aatype, ...]
     UpperCAmelCase_			:							Optional[int]   =			t_atoms_to_global.apply(lowercase_      )
     UpperCAmelCase_			:							Any   =			pred_positions * atom_mask

     return pred_positions





'''simple docstring'''







def 		_lowercase		(	lowercase_  ):



		'''simple docstring'''







		return "".join(chr(ord(lowercase_  ) + 32  ) if "A" <= char <= "Z" else char for char in word  )


if __name__ == "__main__":
						from doctest import testmod

						testmod()





