




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:

    """simple docstring"""


    ...




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

    """simple docstring"""


    ...




def    __SCREAMING_SNAKE_CASE				(					lowercase_   ,       lowercase_   ,       lowercase_ )    ->		List[Any]:

    """simple docstring"""


    __UpperCamelCase											=  aatype == rc.restype_order['''G''']
    __UpperCamelCase											=  rc.atom_order['''CA''']
    __UpperCamelCase											=  rc.atom_order['''CB''']
    __UpperCamelCase											=  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											=  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:

    """simple docstring"""


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

    __UpperCamelCase											=  atomaa_data * batch['''atom37_atom_exists'''][..., None]

    return atomaa_data




def    __SCREAMING_SNAKE_CASE				(					lowercase_ )    ->		torch.Tensor:

    """simple docstring"""


    __UpperCamelCase											=  template_feats['''template_aatype''']
    __UpperCamelCase											=  template_feats['''template_torsion_angles_sin_cos''']
    __UpperCamelCase											=  template_feats['''template_alt_torsion_angles_sin_cos''']
    __UpperCamelCase											=  template_feats['''template_torsion_angles_mask''']
    __UpperCamelCase											=  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:

    """simple docstring"""


    __UpperCamelCase											=  batch['''template_pseudo_beta_mask''']
    __UpperCamelCase											=  template_mask[..., None] * template_mask[..., None, :]

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

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

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

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

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

    __UpperCamelCase											=  batch['''template_all_atom_mask''']
    __UpperCamelCase											=  t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
    __UpperCamelCase											=  template_mask[..., None] * template_mask[..., None, :]

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

    if not use_unit_vector:
        __UpperCamelCase											=  unit_vector * 0.0

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

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

    return act




def    __SCREAMING_SNAKE_CASE				(					lowercase_ )    ->		torch.Tensor:

    """simple docstring"""


    __UpperCamelCase											=  nn.functional.one_hot(batch['''extra_msa''']   ,       23 )
    __UpperCamelCase											=  [
        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:

    """simple docstring"""


    __UpperCamelCase											=  rrgdf[aatype, ...]

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

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

    # [*, N, 8, 2]
    __UpperCamelCase											=  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											=  alpha.new_zeros(default_r.get_rots().get_rot_mats().shape )
    __UpperCamelCase											=  1
    __UpperCamelCase											=  alpha[..., 1]
    __UpperCamelCase											=  -alpha[..., 0]
    __UpperCamelCase											=  alpha

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

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

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

    __UpperCamelCase											=  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											=  r[..., None].compose(lowercase_ )

    return all_frames_to_global




def    __SCREAMING_SNAKE_CASE				(					lowercase_   ,       lowercase_   ,       lowercase_   ,       lowercase_   ,       lowercase_   ,       lowercase_   ,       )    ->		torch.Tensor:

    """simple docstring"""


    __UpperCamelCase											=  group_idx[aatype, ...]

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

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

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

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

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

    return pred_positions












from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


a_										=       {
    "configuration_marian": ["MARIAN_PRETRAINED_CONFIG_ARCHIVE_MAP", "MarianConfig", "MarianOnnxConfig"],
}

try:
 if not is_sentencepiece_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 a_										=       ["MarianTokenizer"]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 a_										=       [
     "MARIAN_PRETRAINED_MODEL_ARCHIVE_LIST",
     "MarianForCausalLM",
     "MarianModel",
     "MarianMTModel",
     "MarianPreTrainedModel",
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 a_										=       ["TFMarianModel", "TFMarianMTModel", "TFMarianPreTrainedModel"]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 a_										=       ["FlaxMarianModel", "FlaxMarianMTModel", "FlaxMarianPreTrainedModel"]

if TYPE_CHECKING:
 from .configuration_marian import MARIAN_PRETRAINED_CONFIG_ARCHIVE_MAP, MarianConfig, MarianOnnxConfig

 try:
  if not is_sentencepiece_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_marian import MarianTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_marian import (
      MARIAN_PRETRAINED_MODEL_ARCHIVE_LIST,
      MarianForCausalLM,
      MarianModel,
      MarianMTModel,
      MarianPreTrainedModel,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_marian import TFMarianModel, TFMarianMTModel, TFMarianPreTrainedModel

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_marian import FlaxMarianModel, FlaxMarianMTModel, FlaxMarianPreTrainedModel

else:
 import sys

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






