


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__lowerCAmelCase	: List[Any]  				={
    'configuration_blip_2': [
        'BLIP_2_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'Blip2Config',
        'Blip2QFormerConfig',
        'Blip2VisionConfig',
    ],
    'processing_blip_2': ['Blip2Processor'],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowerCAmelCase	: int  				=[
						    'BLIP_2_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'Blip2Model',
						    'Blip2QFormerModel',
						    'Blip2PreTrainedModel',
						    'Blip2ForConditionalGeneration',
						    'Blip2VisionModel',
						]

if TYPE_CHECKING:
						from .configuration_blip_a import (
						    BLIP_2_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    BlipaConfig,
						    BlipaQFormerConfig,
						    BlipaVisionConfig,
						)
						from .processing_blip_a import BlipaProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_blip_a import (
												    BLIP_2_PRETRAINED_MODEL_ARCHIVE_LIST,
												    BlipaForConditionalGeneration,
												    BlipaModel,
												    BlipaPreTrainedModel,
												    BlipaQFormerModel,
												    BlipaVisionModel,
												)

else:
						import sys

						__lowerCAmelCase	: Union[str, Any]  				=_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

from typing import Dict

import numpy as np
import torch

from . import residue_constants as rc
from .tensor_utils import tensor_tree_map, tree_map

def 			lowercase_				(			_lowerCamelCase							:       Dict[str, torch.Tensor]):
    lowercase__ :   Any    					=				[]
    lowercase__ :   Optional[int]    					=				[]
    lowercase__ :   Tuple    					=				[]

    for rt in rc.restypes:
        lowercase__ :   Dict    					=				rc.restype_name_to_atomaa_names[rc.restype_atoa[rt]]
        restype_atomaa_to_atomaa_list.append([(rc.atom_order[name] if name else 0) for name in atom_names])
        lowercase__ :   str    					=				{name: i for i, name in enumerate(_lowerCamelCase)}
        restype_atomaa_to_atomaa_list.append(
            [(atom_name_to_idxaa[name] if name in atom_name_to_idxaa else 0) for name in rc.atom_types])

        restype_atomaa_mask_list.append([(1.0 if name else 0.0) for name in atom_names])

    # Add dummy mapping for restype 'UNK'
    restype_atomaa_to_atomaa_list.append([0] * 14)
    restype_atomaa_to_atomaa_list.append([0] * 37)
    restype_atomaa_mask_list.append([0.0] * 14)

    lowercase__ :   Union[str, Any]    					=				torch.tensor(
        _lowerCamelCase		,	dtype=torch.intaa		,	device=protein["aatype"].device		,	)
    lowercase__ :   str    					=				torch.tensor(
        _lowerCamelCase		,	dtype=torch.intaa		,	device=protein["aatype"].device		,	)
    lowercase__ :   List[str]    					=				torch.tensor(
        _lowerCamelCase		,	dtype=torch.floataa		,	device=protein["aatype"].device		,	)
    lowercase__ :   str    					=				protein["aatype"].to(torch.long)

    # create the mapping for (residx, atom14) --> atom37, i.e. an array
    # with shape (num_res, 14) containing the atom37 indices for this protein
    lowercase__ :   Dict    					=				restype_atomaa_to_atomaa[protein_aatype]
    lowercase__ :   str    					=				restype_atomaa_mask[protein_aatype]

    lowercase__ :   List[Any]    					=				residx_atomaa_mask
    lowercase__ :   Optional[Any]    					=				residx_atomaa_to_atomaa.long()

    # create the gather indices for mapping back
    lowercase__ :   str    					=				restype_atomaa_to_atomaa[protein_aatype]
    lowercase__ :   str    					=				residx_atomaa_to_atomaa.long()

    # create the corresponding mask
    lowercase__ :   Optional[Any]    					=				torch.zeros([21, 37]		,	dtype=torch.floataa		,	device=protein["aatype"].device)
    for restype, restype_letter in enumerate(rc.restypes):
        lowercase__ :   Tuple    					=				rc.restype_atoa[restype_letter]
        lowercase__ :   List[Any]    					=				rc.residue_atoms[restype_name]
        for atom_name in atom_names:
            lowercase__ :   Optional[int]    					=				rc.atom_order[atom_name]
            lowercase__ :   Tuple    					=				1

    lowercase__ :   Dict    					=				restype_atomaa_mask[protein_aatype]
    lowercase__ :   Any    					=				residx_atomaa_mask

    return protein

def 			lowercase_				(			_lowerCamelCase							:       Dict[str, torch.Tensor]):
    lowercase__ :   Tuple    					=				tree_map(lambda _lowerCamelCase: torch.tensor(_lowerCamelCase		,	device=batch["aatype"].device)		,	_lowerCamelCase		,	np.ndarray)
    lowercase__ :   List[str]    					=				tensor_tree_map(lambda _lowerCamelCase: np.array(_lowerCamelCase)		,	make_atomaa_masks(_lowerCamelCase))
    return out



