
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_	( __lowercase     :			torch.Tensor ,      __lowercase     :			torch.Tensor ,      __lowercase     :			None				)				->						torch.Tensor:
			...






@overload
def  a_	( __lowercase     :			torch.Tensor ,      __lowercase     :			torch.Tensor ,      __lowercase     :			torch.Tensor				)				->						Tuple[torch.Tensor, torch.Tensor]:
			...






def  a_	( __lowercase     :			List[Any] ,      __lowercase     :			Tuple ,      __lowercase     :			Optional[int]				)				->						List[Any]:
			_snake_case						=    aatype == rc.restype_order['G']
			_snake_case						=    rc.atom_order['CA']
			_snake_case						=    rc.atom_order['CB']
			_snake_case						=    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:
						_snake_case						=    torch.where(
						    __lowercase ,      all_atom_masks[..., ca_idx] ,      all_atom_masks[..., cb_idx] ,      )
						return pseudo_beta, pseudo_beta_mask
			else:
						return pseudo_beta






def  a_	( __lowercase     :			torch.Tensor ,      __lowercase     :			Dict[str, torch.Tensor]				)				->						torch.Tensor:
			_snake_case						=    batched_gather(
			    __lowercase ,      batch['residx_atom37_to_atom14'] ,      dim=-2 ,      no_batch_dims=len(atomaa.shape[:-2]				) ,      )

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

			return atomaa_data






def  a_	( __lowercase     :			Dict[str, torch.Tensor]				)				->						torch.Tensor:
			_snake_case						=    template_feats['template_aatype']
			_snake_case						=    template_feats['template_torsion_angles_sin_cos']
			_snake_case						=    template_feats['template_alt_torsion_angles_sin_cos']
			_snake_case						=    template_feats['template_torsion_angles_mask']
			_snake_case						=    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  a_	( __lowercase     :			Dict[str, torch.Tensor] ,      __lowercase     :			torch.types.Number ,      __lowercase     :			torch.types.Number ,      __lowercase     :			int ,      __lowercase     :			bool = False ,      __lowercase     :			float = 1E-20 ,      __lowercase     :			float = 1E8 ,      )				->						torch.Tensor:
			_snake_case						=    batch['template_pseudo_beta_mask']
			_snake_case						=    template_mask[..., None] * template_mask[..., None, :]

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

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

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

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

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

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

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

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

			if not use_unit_vector:
						_snake_case						=    unit_vector * 0.0

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

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

			return act






def  a_	( __lowercase     :			Dict[str, torch.Tensor]				)				->						torch.Tensor:
			_snake_case						=    nn.functional.one_hot(batch['extra_msa'] ,      23				)
			_snake_case						=    [
			    msa_ahot,
			    batch['extra_has_deletion'].unsqueeze(-1				),
			    batch['extra_deletion_value'].unsqueeze(-1				),
			]
			return torch.cat(__lowercase ,      dim=-1				)






def  a_	( __lowercase     :			Rigid ,      __lowercase     :			torch.Tensor ,      __lowercase     :			torch.Tensor ,      __lowercase     :			torch.Tensor ,      )				->						Rigid:
			# [*, N, 8, 4, 4]
			_snake_case						=    rrgdf[aatype, ...]

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

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

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

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

			_snake_case						=    default_r.compose(Rigid(Rotation(rot_mats=__lowercase				) ,      __lowercase				)				)

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

			_snake_case						=    all_frames[..., 4]
			_snake_case						=    chia_frame_to_bb.compose(__lowercase				)
			_snake_case						=    chia_frame_to_bb.compose(__lowercase				)
			_snake_case						=    chia_frame_to_bb.compose(__lowercase				)

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

			_snake_case						=    r[..., None].compose(__lowercase				)

			return all_frames_to_global






def  a_	( __lowercase     :			Rigid ,      __lowercase     :			torch.Tensor ,      __lowercase     :			torch.Tensor ,      __lowercase     :			torch.Tensor ,      __lowercase     :			torch.Tensor ,      __lowercase     :			torch.Tensor ,      )				->						torch.Tensor:
			# [*, N, 14]
			_snake_case						=    group_idx[aatype, ...]

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

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

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

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

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

			return pred_positions

# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
    is_vision_available,
)


_lowerCamelCase :       int     					=    {
    '''configuration_tvlt''': ['''TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''TvltConfig'''],
    '''feature_extraction_tvlt''': ['''TvltFeatureExtractor'''],
    '''processing_tvlt''': ['''TvltProcessor'''],
}

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_lowerCamelCase :       str     					=    [
			    '''TVLT_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''TvltModel''',
			    '''TvltForPreTraining''',
			    '''TvltForAudioVisualClassification''',
			    '''TvltPreTrainedModel''',
			]

try:
			if not is_vision_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_lowerCamelCase :       str     					=    ['''TvltImageProcessor''']


if TYPE_CHECKING:
			from .configuration_tvlt import TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP, TvltConfig
			from .processing_tvlt import TvltProcessor
			from .feature_extraction_tvlt import TvltFeatureExtractor

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tvlt import (
						    TVLT_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TvltForAudioVisualClassification,
						    TvltForPreTraining,
						    TvltModel,
						    TvltPreTrainedModel,
						)

			try:
						if not is_vision_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .image_processing_tvlt import TvltImageProcessor


else:
			import sys

			_lowerCamelCase :       Dict     					=    _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)