




"""simple docstring"""



from typing import TYPE_CHECKING

from ...utils import _LazyModule


SCREAMING_SNAKE_CASE       = {"tokenization_bert_japanese": ["BertJapaneseTokenizer", "CharacterTokenizer", "MecabTokenizer"]}


if TYPE_CHECKING:
      from .tokenization_bert_japanese import BertJapaneseTokenizer, CharacterTokenizer, MecabTokenizer

else:
      import sys

      SCREAMING_SNAKE_CASE       = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)











"""simple docstring"""



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 						_SCREAMING_SNAKE_CASE     (							lowercase_    ,				lowercase_    ,				lowercase_		)		->	torch.Tensor:
 ...







@overload
def 						_SCREAMING_SNAKE_CASE     (							lowercase_    ,				lowercase_    ,				lowercase_		)		->	Tuple[torch.Tensor, torch.Tensor]:
 ...







def 						_SCREAMING_SNAKE_CASE     (							lowercase_    ,				lowercase_    ,				lowercase_		)		->	Dict:
 A__ =       aatype == rc.restype_order["G"]
 A__ =       rc.atom_order["CA"]
 A__ =       rc.atom_order["CB"]
 A__ =       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:
  A__ =       torch.where(
      lowercase_    ,				all_atom_masks[..., ca_idx]    ,				all_atom_masks[..., cb_idx]    ,				)
  return pseudo_beta, pseudo_beta_mask
 else:
  return pseudo_beta







def 						_SCREAMING_SNAKE_CASE     (							lowercase_    ,				lowercase_		)		->	torch.Tensor:
 A__ =       batched_gather(
     lowercase_    ,				batch["residx_atom37_to_atom14"]    ,				dim=-2    ,				no_batch_dims=len(atomaa.shape[:-2]		)    ,				)

 A__ =       atomaa_data * batch["atom37_atom_exists"][..., None]

 return atomaa_data







def 						_SCREAMING_SNAKE_CASE     (							lowercase_		)		->	torch.Tensor:
 A__ =       template_feats["template_aatype"]
 A__ =       template_feats["template_torsion_angles_sin_cos"]
 A__ =       template_feats["template_alt_torsion_angles_sin_cos"]
 A__ =       template_feats["template_torsion_angles_mask"]
 A__ =       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 						_SCREAMING_SNAKE_CASE     (							lowercase_    ,				lowercase_    ,				lowercase_    ,				lowercase_    ,				lowercase_ = False    ,				lowercase_ = 1E-20    ,				lowercase_ = 1E8    ,				)		->	torch.Tensor:
 A__ =       batch["template_pseudo_beta_mask"]
 A__ =       template_mask[..., None] * template_mask[..., None, :]

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

 A__ =       [dgram, template_mask_ad[..., None]]

 A__ =       nn.functional.one_hot(
     batch["template_aatype"]    ,				rc.restype_num + 2    ,				)

 A__ =       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		)		)

 A__,   A__,   A__ =       [rc.atom_order[a] for a in ["N", "CA", "C"]]
 A__ =       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_    ,				)
 A__ =       rigids.get_trans()[..., None, :, :]
 A__ =       rigids[..., None].invert_apply(lowercase_		)

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

 A__ =       batch["template_all_atom_mask"]
 A__ =       t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
 A__ =       template_mask[..., None] * template_mask[..., None, :]

 A__ =       inv_distance_scalar * template_mask_ad
 A__ =       rigid_vec * inv_distance_scalar[..., None]

 if not use_unit_vector:
  A__ =       unit_vector * 0.0

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

 A__ =       torch.cat(lowercase_    ,				dim=-1		)
 A__ =       act * template_mask_ad[..., None]

 return act







def 						_SCREAMING_SNAKE_CASE     (							lowercase_		)		->	torch.Tensor:
 A__ =       nn.functional.one_hot(batch["extra_msa"]    ,				23		)
 A__ =       [
     msa_ahot,
     batch["extra_has_deletion"].unsqueeze(-1		),
     batch["extra_deletion_value"].unsqueeze(-1		),
 ]
 return torch.cat(lowercase_    ,				dim=-1		)







def 						_SCREAMING_SNAKE_CASE     (							lowercase_    ,				lowercase_    ,				lowercase_    ,				lowercase_    ,				)		->	Rigid:
 # [*, N, 8, 4, 4]
 A__ =       rrgdf[aatype, ...]

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

 A__ =       alpha.new_zeros((*((1,) * len(alpha.shape[:-1]		)), 2)		)
 A__ =       1

 # [*, N, 8, 2]
 A__ =       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.

 A__ =       alpha.new_zeros(default_r.get_rots().get_rot_mats().shape		)
 A__ =       1
 A__ =       alpha[..., 1]
 A__ =       -alpha[..., 0]
 A__ =       alpha

 A__ =       default_r.compose(Rigid(Rotation(rot_mats=lowercase_		)    ,				lowercase_		)		)

 A__ =       all_frames[..., 5]
 A__ =       all_frames[..., 6]
 A__ =       all_frames[..., 7]

 A__ =       all_frames[..., 4]
 A__ =       chia_frame_to_bb.compose(lowercase_		)
 A__ =       chia_frame_to_bb.compose(lowercase_		)
 A__ =       chia_frame_to_bb.compose(lowercase_		)

 A__ =       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    ,				)

 A__ =       r[..., None].compose(lowercase_		)

 return all_frames_to_global







def 						_SCREAMING_SNAKE_CASE     (							lowercase_    ,				lowercase_    ,				lowercase_    ,				lowercase_    ,				lowercase_    ,				lowercase_    ,				)		->	torch.Tensor:
 # [*, N, 14]
 A__ =       group_idx[aatype, ...]

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

 # [*, N, 14, 8]
 A__ =       r[..., None, :] * group_mask_one_hot

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

 # [*, N, 14, 1]
 A__ =       atom_mask[aatype, ...].unsqueeze(-1		)

 # [*, N, 14, 3]
 A__ =       lit_positions[aatype, ...]
 A__ =       t_atoms_to_global.apply(lowercase_		)
 A__ =       pred_positions * atom_mask

 return pred_positions





