



"""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 	snake_case__  (						__lowerCamelCase							:       torch.Tensor				,						__lowerCamelCase							:       torch.Tensor				,						__lowerCamelCase							:       None      ):
			"""simple docstring"""
			...






@overload
def 	snake_case__  (						__lowerCamelCase							:       torch.Tensor				,						__lowerCamelCase							:       torch.Tensor				,						__lowerCamelCase							:       torch.Tensor      ):
			"""simple docstring"""
			...






def 	snake_case__  (						__lowerCamelCase							:       List[str]				,						__lowerCamelCase							:       Any				,						__lowerCamelCase							:       List[str]      ):
			"""simple docstring"""
			lowerCamelCase__						:						Union[str, Any]						      =aatype == rc.restype_order['''G''']
			lowerCamelCase__						:						Any						      =rc.atom_order['''CA''']
			lowerCamelCase__						:						Any						      =rc.atom_order['''CB''']
			lowerCamelCase__						:						Optional[int]						      =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:
						lowerCamelCase__						:						Union[str, Any]						      =torch.where(
						    __lowerCamelCase				,						all_atom_masks[..., ca_idx]				,						all_atom_masks[..., cb_idx]				,						)
						return pseudo_beta, pseudo_beta_mask
			else:
						return pseudo_beta






def 	snake_case__  (						__lowerCamelCase							:       torch.Tensor				,						__lowerCamelCase							:       Dict[str, torch.Tensor]      ):
			"""simple docstring"""
			lowerCamelCase__						:						Any						      =batched_gather(
			    __lowerCamelCase				,						batch['''residx_atom37_to_atom14''']				,						dim=-2				,						no_batch_dims=len(atomaa.shape[:-2]      )				,						)

			lowerCamelCase__						:						Union[str, Any]						      =atomaa_data * batch['''atom37_atom_exists'''][..., None]

			return atomaa_data






def 	snake_case__  (						__lowerCamelCase							:       Dict[str, torch.Tensor]      ):
			"""simple docstring"""
			lowerCamelCase__						:						Optional[int]						      =template_feats['''template_aatype''']
			lowerCamelCase__						:						List[str]						      =template_feats['''template_torsion_angles_sin_cos''']
			lowerCamelCase__						:						Optional[int]						      =template_feats['''template_alt_torsion_angles_sin_cos''']
			lowerCamelCase__						:						Optional[Any]						      =template_feats['''template_torsion_angles_mask''']
			lowerCamelCase__						:						Union[str, Any]						      =torch.cat(
			    [
			        nn.functional.one_hot(__lowerCamelCase				,						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 	snake_case__  (						__lowerCamelCase							:       Dict[str, torch.Tensor]				,						__lowerCamelCase							:       torch.types.Number				,						__lowerCamelCase							:       torch.types.Number				,						__lowerCamelCase							:       int				,						__lowerCamelCase							:       bool = False				,						__lowerCamelCase							:       float = 1e-2_0				,						__lowerCamelCase							:       float = 1e8				,						):
			"""simple docstring"""
			lowerCamelCase__						:						Union[str, Any]						      =batch['''template_pseudo_beta_mask''']
			lowerCamelCase__						:						Any						      =template_mask[..., None] * template_mask[..., None, :]

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

			lowerCamelCase__						:						List[str]						      =[dgram, template_mask_ad[..., None]]

			lowerCamelCase__						:						torch.LongTensor						      =nn.functional.one_hot(
			    batch['''template_aatype''']				,						rc.restype_num + 2				,						)

			lowerCamelCase__						:						Union[str, Any]						      =batch['''template_aatype'''].shape[-1]
			to_concat.append(aatype_one_hot[..., None, :, :].expand(*aatype_one_hot.shape[:-2]				,						__lowerCamelCase				,						-1				,						-1      )      )
			to_concat.append(aatype_one_hot[..., None, :].expand(*aatype_one_hot.shape[:-2]				,						-1				,						__lowerCamelCase				,						-1      )      )

			lowerCamelCase__      ,  lowerCamelCase__      ,  lowerCamelCase__						:						Tuple						      =[rc.atom_order[a] for a in ['''N''', '''CA''', '''C''']]
			lowerCamelCase__						:						Dict						      =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=__lowerCamelCase				,						)
			lowerCamelCase__						:						List[str]						      =rigids.get_trans()[..., None, :, :]
			lowerCamelCase__						:						Any						      =rigids[..., None].invert_apply(__lowerCamelCase      )

			lowerCamelCase__						:						List[str]						      =torch.rsqrt(eps + torch.sum(rigid_vec**2				,						dim=-1      )      )

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

			lowerCamelCase__						:						Tuple						      =inv_distance_scalar * template_mask_ad
			lowerCamelCase__						:						Dict						      =rigid_vec * inv_distance_scalar[..., None]

			if not use_unit_vector:
						lowerCamelCase__						:						List[str]						      =unit_vector * 0.0

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

			lowerCamelCase__						:						int						      =torch.cat(__lowerCamelCase				,						dim=-1      )
			lowerCamelCase__						:						int						      =act * template_mask_ad[..., None]

			return act






def 	snake_case__  (						__lowerCamelCase							:       Dict[str, torch.Tensor]      ):
			"""simple docstring"""
			lowerCamelCase__						:						torch.LongTensor						      =nn.functional.one_hot(batch['''extra_msa''']				,						23      )
			lowerCamelCase__						:						Optional[int]						      =[
			    msa_ahot,
			    batch['''extra_has_deletion'''].unsqueeze(-1      ),
			    batch['''extra_deletion_value'''].unsqueeze(-1      ),
			]
			return torch.cat(__lowerCamelCase				,						dim=-1      )






def 	snake_case__  (						__lowerCamelCase							:       Rigid				,						__lowerCamelCase							:       torch.Tensor				,						__lowerCamelCase							:       torch.Tensor				,						__lowerCamelCase							:       torch.Tensor				,						):
			"""simple docstring"""
			# [*, N, 8, 4, 4]
			lowerCamelCase__						:						str						      =rrgdf[aatype, ...]

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

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

			# [*, N, 8, 2]
			lowerCamelCase__						:						Optional[Any]						      =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.

			lowerCamelCase__						:						int						      =alpha.new_zeros(default_r.get_rots().get_rot_mats().shape      )
			lowerCamelCase__						:						Any						      =1
			lowerCamelCase__						:						int						      =alpha[..., 1]
			lowerCamelCase__						:						Optional[int]						      =-alpha[..., 0]
			lowerCamelCase__						:						Union[str, Any]						      =alpha

			lowerCamelCase__						:						Optional[int]						      =default_r.compose(Rigid(Rotation(rot_mats=__lowerCamelCase      )				,						__lowerCamelCase      )      )

			lowerCamelCase__						:						Dict						      =all_frames[..., 5]
			lowerCamelCase__						:						int						      =all_frames[..., 6]
			lowerCamelCase__						:						Optional[int]						      =all_frames[..., 7]

			lowerCamelCase__						:						Optional[int]						      =all_frames[..., 4]
			lowerCamelCase__						:						Union[str, Any]						      =chia_frame_to_bb.compose(__lowerCamelCase      )
			lowerCamelCase__						:						Tuple						      =chia_frame_to_bb.compose(__lowerCamelCase      )
			lowerCamelCase__						:						Any						      =chia_frame_to_bb.compose(__lowerCamelCase      )

			lowerCamelCase__						:						Tuple						      =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				,						)

			lowerCamelCase__						:						Union[str, Any]						      =r[..., None].compose(__lowerCamelCase      )

			return all_frames_to_global






def 	snake_case__  (						__lowerCamelCase							:       Rigid				,						__lowerCamelCase							:       torch.Tensor				,						__lowerCamelCase							:       torch.Tensor				,						__lowerCamelCase							:       torch.Tensor				,						__lowerCamelCase							:       torch.Tensor				,						__lowerCamelCase							:       torch.Tensor				,						):
			"""simple docstring"""
			# [*, N, 14]
			lowerCamelCase__						:						Union[str, Any]						      =group_idx[aatype, ...]

			# [*, N, 14, 8]
			lowerCamelCase__						:						torch.LongTensor						      =nn.functional.one_hot(
			    __lowerCamelCase				,						num_classes=default_frames.shape[-3]				,						)

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

			# [*, N, 14]
			lowerCamelCase__						:						Union[str, Any]						      =t_atoms_to_global.map_tensor_fn(lambda __lowerCamelCase      : torch.sum(__lowerCamelCase				,						dim=-1      )      )

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

			# [*, N, 14, 3]
			lowerCamelCase__						:						str						      =lit_positions[aatype, ...]
			lowerCamelCase__						:						str						      =t_atoms_to_global.apply(__lowerCamelCase      )
			lowerCamelCase__						:						Any						      =pred_positions * atom_mask

			return pred_positions






'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__UpperCAmelCase												=   {'configuration_sew_d': ['SEW_D_PRETRAINED_CONFIG_ARCHIVE_MAP', 'SEWDConfig']}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   __UpperCAmelCase												=   [
       'SEW_D_PRETRAINED_MODEL_ARCHIVE_LIST',
       'SEWDForCTC',
       'SEWDForSequenceClassification',
       'SEWDModel',
       'SEWDPreTrainedModel',
   ]

if TYPE_CHECKING:
   from .configuration_sew_d import SEW_D_PRETRAINED_CONFIG_ARCHIVE_MAP, SEWDConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_sew_d import (
          SEW_D_PRETRAINED_MODEL_ARCHIVE_LIST,
          SEWDForCTC,
          SEWDForSequenceClassification,
          SEWDModel,
          SEWDPreTrainedModel,
      )


else:
   import sys

   __UpperCAmelCase												=   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


