code: 
  
  
  
  
  
  
  """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        A	(							__snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    __snake_case:   None     )						->		torch.Tensor:
  
         """simple docstring"""
  
  
  
  
  
         ...
  
  
  @overload
  def        A	(							__snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor     )						->		Tuple[torch.Tensor, torch.Tensor]:
  
         """simple docstring"""
  
  
  
  
  
         ...
  
  
  def        A	(							__snake_case:   List[Any]   ,    __snake_case:   Any   ,    __snake_case:   List[Any]     )						->		Union[str, Any]:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						aatype == rc.restype_order['G']
         __magic_name__										=						rc.atom_order['CA']
         __magic_name__										=						rc.atom_order['CB']
         __magic_name__										=						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:
                __magic_name__										=						torch.where(
                    __snake_case   ,    all_atom_masks[..., ca_idx]   ,    all_atom_masks[..., cb_idx]   ,    )
                return pseudo_beta, pseudo_beta_mask
         else:
                return pseudo_beta
  
  
  def        A	(							__snake_case:   torch.Tensor   ,    __snake_case:   Dict[str, torch.Tensor]     )						->		torch.Tensor:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						batched_gather(
             __snake_case   ,    batch['residx_atom37_to_atom14']   ,    dim=-2   ,    no_batch_dims=len(atomaa.shape[:-2]     )   ,    )
  
         __magic_name__										=						atomaa_data * batch['atom37_atom_exists'][..., None]
  
         return atomaa_data
  
  
  def        A	(							__snake_case:   Dict[str, torch.Tensor]     )						->		torch.Tensor:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						template_feats['template_aatype']
         __magic_name__										=						template_feats['template_torsion_angles_sin_cos']
         __magic_name__										=						template_feats['template_alt_torsion_angles_sin_cos']
         __magic_name__										=						template_feats['template_torsion_angles_mask']
         __magic_name__										=						torch.cat(
             [
                 nn.functional.one_hot(__snake_case   ,    2_2     ),
                 torsion_angles_sin_cos.reshape(*torsion_angles_sin_cos.shape[:-2]   ,    1_4     ),
                 alt_torsion_angles_sin_cos.reshape(*alt_torsion_angles_sin_cos.shape[:-2]   ,    1_4     ),
                 torsion_angles_mask,
             ]   ,    dim=-1   ,    )
  
         return template_angle_feat
  
  
  def        A	(							__snake_case:   Dict[str, torch.Tensor]   ,    __snake_case:   torch.types.Number   ,    __snake_case:   torch.types.Number   ,    __snake_case:   int   ,    __snake_case:   bool = False   ,    __snake_case:   float = 1E-20   ,    __snake_case:   float = 1E8   ,    )						->		torch.Tensor:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						batch['template_pseudo_beta_mask']
         __magic_name__										=						template_mask[..., None] * template_mask[..., None, :]
  
         # Compute distogram (this seems to differ slightly from Alg. 5)
         __magic_name__										=						batch['template_pseudo_beta']
         __magic_name__										=						torch.sum((tpb[..., None, :] - tpb[..., None, :, :]) ** 2   ,    dim=-1   ,    keepdim=__snake_case     )
         __magic_name__										=						torch.linspace(__snake_case   ,    __snake_case   ,    __snake_case   ,    device=tpb.device     ) ** 2
         __magic_name__										=						torch.cat([lower[1:], lower.new_tensor([inf]     )]   ,    dim=-1     )
         __magic_name__										=						((dgram > lower) * (dgram < upper)).type(dgram.dtype     )
  
         __magic_name__										=						[dgram, template_mask_ad[..., None]]
  
         __magic_name__										=						nn.functional.one_hot(
             batch['template_aatype']   ,    rc.restype_num + 2   ,    )
  
         __magic_name__										=						batch['template_aatype'].shape[-1]
         to_concat.append(aatype_one_hot[..., None, :, :].expand(*aatype_one_hot.shape[:-2]   ,    __snake_case   ,    -1   ,    -1     )     )
         to_concat.append(aatype_one_hot[..., None, :].expand(*aatype_one_hot.shape[:-2]   ,    -1   ,    __snake_case   ,    -1     )     )
  
         __magic_name__							,     __magic_name__							,     __magic_name__										=						[rc.atom_order[a] for a in ['N', 'CA', 'C']]
         __magic_name__										=						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=__snake_case   ,    )
         __magic_name__										=						rigids.get_trans()[..., None, :, :]
         __magic_name__										=						rigids[..., None].invert_apply(__snake_case     )
  
         __magic_name__										=						torch.rsqrt(eps + torch.sum(rigid_vec**2   ,    dim=-1     )     )
  
         __magic_name__										=						batch['template_all_atom_mask']
         __magic_name__										=						t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
         __magic_name__										=						template_mask[..., None] * template_mask[..., None, :]
  
         __magic_name__										=						inv_distance_scalar * template_mask_ad
         __magic_name__										=						rigid_vec * inv_distance_scalar[..., None]
  
         if not use_unit_vector:
                __magic_name__										=						unit_vector * 0.0
  
         to_concat.extend(torch.unbind(unit_vector[..., None, :]   ,    dim=-1     )     )
         to_concat.append(template_mask_ad[..., None]     )
  
         __magic_name__										=						torch.cat(__snake_case   ,    dim=-1     )
         __magic_name__										=						act * template_mask_ad[..., None]
  
         return act
  
  
  def        A	(							__snake_case:   Dict[str, torch.Tensor]     )						->		torch.Tensor:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						nn.functional.one_hot(batch['extra_msa']   ,    2_3     )
         __magic_name__										=						[
             msa_ahot,
             batch['extra_has_deletion'].unsqueeze(-1     ),
             batch['extra_deletion_value'].unsqueeze(-1     ),
         ]
         return torch.cat(__snake_case   ,    dim=-1     )
  
  
  def        A	(							__snake_case:   Rigid   ,    __snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    )						->		Rigid:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						rrgdf[aatype, ...]
  
         # [*, N, 8] transformations, i.e.
         #   One [*, N, 8, 3, 3] rotation matrix and
         #   One [*, N, 8, 3]    translation matrix
         __magic_name__										=						r.from_tensor_axa(__snake_case     )
  
         __magic_name__										=						alpha.new_zeros((*((1,) * len(alpha.shape[:-1]     )), 2)     )
         __magic_name__										=						1
  
         # [*, N, 8, 2]
         __magic_name__										=						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.
  
         __magic_name__										=						alpha.new_zeros(default_r.get_rots().get_rot_mats().shape     )
         __magic_name__										=						1
         __magic_name__										=						alpha[..., 1]
         __magic_name__										=						-alpha[..., 0]
         __magic_name__										=						alpha
  
         __magic_name__										=						default_r.compose(Rigid(Rotation(rot_mats=__snake_case     )   ,    __snake_case     )     )
  
         __magic_name__										=						all_frames[..., 5]
         __magic_name__										=						all_frames[..., 6]
         __magic_name__										=						all_frames[..., 7]
  
         __magic_name__										=						all_frames[..., 4]
         __magic_name__										=						chia_frame_to_bb.compose(__snake_case     )
         __magic_name__										=						chia_frame_to_bb.compose(__snake_case     )
         __magic_name__										=						chia_frame_to_bb.compose(__snake_case     )
  
         __magic_name__										=						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   ,    )
  
         __magic_name__										=						r[..., None].compose(__snake_case     )
  
         return all_frames_to_global
  
  
  
  
  
  
  def        A	(							__snake_case:   Rigid   ,    __snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    )						->		torch.Tensor:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						group_idx[aatype, ...]
  
         # [*, N, 14, 8]
         __magic_name__										=						nn.functional.one_hot(
             __snake_case   ,    num_classes=default_frames.shape[-3]   ,    )
  
         # [*, N, 14, 8]
         __magic_name__										=						r[..., None, :] * group_mask_one_hot
  
         # [*, N, 14]
         __magic_name__										=						t_atoms_to_global.map_tensor_fn(lambda __snake_case     : torch.sum(__snake_case   ,    dim=-1     )     )
  
         # [*, N, 14, 1]
         __magic_name__										=						atom_mask[aatype, ...].unsqueeze(-1     )
  
         # [*, N, 14, 3]
         __magic_name__										=						lit_positions[aatype, ...]
         __magic_name__										=						t_atoms_to_global.apply(__snake_case     )
         __magic_name__										=						pred_positions * atom_mask
  
         return pred_positions
  
  
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available
  
  
  snake_case   :   Optional[int]    		=		{
      """configuration_splinter""": ["""SPLINTER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """SplinterConfig"""],
      """tokenization_splinter""": ["""SplinterTokenizer"""],
  }
  
  try:
   if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   snake_case   :   Dict    		=		["""SplinterTokenizerFast"""]
  
  try:
   if not is_torch_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   snake_case   :   Dict    		=		[
       """SPLINTER_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """SplinterForQuestionAnswering""",
       """SplinterForPreTraining""",
       """SplinterLayer""",
       """SplinterModel""",
       """SplinterPreTrainedModel""",
   ]
  
  
  if TYPE_CHECKING:
   from .configuration_splinter import SPLINTER_PRETRAINED_CONFIG_ARCHIVE_MAP, SplinterConfig
   from .tokenization_splinter import SplinterTokenizer
  
   try:
    if not is_tokenizers_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .tokenization_splinter_fast import SplinterTokenizerFast
  
   try:
    if not is_torch_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_splinter import (
        SPLINTER_PRETRAINED_MODEL_ARCHIVE_LIST,
        SplinterForPreTraining,
        SplinterForQuestionAnswering,
        SplinterLayer,
        SplinterModel,
        SplinterPreTrainedModel,
    )
  
  
  else:
   import sys
  
   snake_case   :   List[str]    		=		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)