





'''simple docstring'''




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 _lowerCAmelCase     (      _lowerCAmelCase    )->     Dict[str, torch.Tensor]:
 __UpperCAmelCase					=   []
 __UpperCAmelCase					=   []
 __UpperCAmelCase					=   []

 for rt in rc.restypes:
  __UpperCAmelCase					=   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]    )
  __UpperCAmelCase					=   {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    )

 __UpperCAmelCase					=   torch.tensor(
     _lowerCAmelCase       ,    dtype=torch.intaa       ,    device=protein['aatype'].device       ,    )
 __UpperCAmelCase					=   torch.tensor(
     _lowerCAmelCase       ,    dtype=torch.intaa       ,    device=protein['aatype'].device       ,    )
 __UpperCAmelCase					=   torch.tensor(
     _lowerCAmelCase       ,    dtype=torch.floataa       ,    device=protein['aatype'].device       ,    )
 __UpperCAmelCase					=   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
 __UpperCAmelCase					=   restype_atomaa_to_atomaa[protein_aatype]
 __UpperCAmelCase					=   restype_atomaa_mask[protein_aatype]

 __UpperCAmelCase					=   residx_atomaa_mask
 __UpperCAmelCase					=   residx_atomaa_to_atomaa.long()

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

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

 __UpperCAmelCase					=   restype_atomaa_mask[protein_aatype]
 __UpperCAmelCase					=   residx_atomaa_mask

 return protein







def _lowerCAmelCase     (      _lowerCAmelCase    )->     Dict[str, np.ndarray]:
 __UpperCAmelCase					=   tree_map(lambda _lowerCAmelCase    : torch.tensor(_lowerCAmelCase       ,    device=batch['aatype'].device    )       ,    _lowerCAmelCase       ,    np.ndarray    )
 __UpperCAmelCase					=   tensor_tree_map(lambda _lowerCAmelCase    : np.array(_lowerCAmelCase    )       ,    make_atomaa_masks(_lowerCAmelCase    )    )
 return out












'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_A:					List[str]							=				{
    """configuration_luke""": ["""LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """LukeConfig"""],
    """tokenization_luke""": ["""LukeTokenizer"""],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A:					Union[str, Any]							=				[
        """LUKE_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """LukeForEntityClassification""",
        """LukeForEntityPairClassification""",
        """LukeForEntitySpanClassification""",
        """LukeForMultipleChoice""",
        """LukeForQuestionAnswering""",
        """LukeForSequenceClassification""",
        """LukeForTokenClassification""",
        """LukeForMaskedLM""",
        """LukeModel""",
        """LukePreTrainedModel""",
    ]


if TYPE_CHECKING:
    from .configuration_luke import LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP, LukeConfig
    from .tokenization_luke import LukeTokenizer

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_luke import (
            LUKE_PRETRAINED_MODEL_ARCHIVE_LIST,
            LukeForEntityClassification,
            LukeForEntityPairClassification,
            LukeForEntitySpanClassification,
            LukeForMaskedLM,
            LukeForMultipleChoice,
            LukeForQuestionAnswering,
            LukeForSequenceClassification,
            LukeForTokenClassification,
            LukeModel,
            LukePreTrainedModel,
        )

else:
    import sys

    _A:					str							=				_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





