


'''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    _snake_case  (	A			)		->       Dict[str, torch.Tensor]:
							lowerCAmelCase__			  =      []
							lowerCAmelCase__			  =      []
							lowerCAmelCase__			  =      []

							for rt in rc.restypes:
														lowerCAmelCase__			  =      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]			)
														lowerCAmelCase__			  =      {name: i for i, name in enumerate(A			)}
														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			)

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

							lowerCAmelCase__			  =      residx_atomaa_mask
							lowerCAmelCase__			  =      residx_atomaa_to_atomaa.long()

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

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

							lowerCAmelCase__			  =      restype_atomaa_mask[protein_aatype]
							lowerCAmelCase__			  =      residx_atomaa_mask

							return protein






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




'''simple docstring'''
from typing import TYPE_CHECKING

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


snake_case_					:      Tuple    			=    {
    'configuration_layoutlmv2': ['LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LayoutLMv2Config'],
    'processing_layoutlmv2': ['LayoutLMv2Processor'],
    'tokenization_layoutlmv2': ['LayoutLMv2Tokenizer'],
}

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_					:      int    			=    ['LayoutLMv2TokenizerFast']

try:
					if not is_vision_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_					:      Union[str, Any]    			=    ['LayoutLMv2FeatureExtractor']
					snake_case_					:      str    			=    ['LayoutLMv2ImageProcessor']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_					:      Optional[int]    			=    [
					    'LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'LayoutLMv2ForQuestionAnswering',
					    'LayoutLMv2ForSequenceClassification',
					    'LayoutLMv2ForTokenClassification',
					    'LayoutLMv2Layer',
					    'LayoutLMv2Model',
					    'LayoutLMv2PreTrainedModel',
					]

if TYPE_CHECKING:
					from .configuration_layoutlmva import LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP, LayoutLMvaConfig
					from .processing_layoutlmva import LayoutLMvaProcessor
					from .tokenization_layoutlmva import LayoutLMvaTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_layoutlmva_fast import LayoutLMvaTokenizerFast

					try:
										if not is_vision_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .feature_extraction_layoutlmva import LayoutLMvaFeatureExtractor, LayoutLMvaImageProcessor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_layoutlmva import (
										    LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST,
										    LayoutLMvaForQuestionAnswering,
										    LayoutLMvaForSequenceClassification,
										    LayoutLMvaForTokenClassification,
										    LayoutLMvaLayer,
										    LayoutLMvaModel,
										    LayoutLMvaPreTrainedModel,
										)
else:
					import sys

					snake_case_					:      int    			=    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


