





from typing import List, Optional, Union

from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType



class     _UpperCAmelCase   (   _UpperCamelCase   ):

  """simple docstring"""


  a_      =			["""image_processor""", """tokenizer"""]
  a_      =			"""BlipImageProcessor"""
  a_      =			("""BertTokenizer""", """BertTokenizerFast""")






  def __init__(    self			:		Dict ,  lowerCAmelCase_			:		int ,  lowerCAmelCase_			:		Union[str, Any]					)							->						int:
     __lowerCAmelCase							     =     False
     super().__init__(lowerCAmelCase_ ,  lowerCAmelCase_					)
     __lowerCAmelCase							     =     self.image_processor






  def __call__(    self			:		Tuple ,  lowerCAmelCase_			:		ImageInput = None ,  lowerCAmelCase_			:		Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None ,  lowerCAmelCase_			:		bool = True ,  lowerCAmelCase_			:		Union[bool, str, PaddingStrategy] = False ,  lowerCAmelCase_			:		Union[bool, str, TruncationStrategy] = None ,  lowerCAmelCase_			:		Optional[int] = None ,  lowerCAmelCase_			:		int = 0 ,  lowerCAmelCase_			:		Optional[int] = None ,  lowerCAmelCase_			:		Optional[bool] = None ,  lowerCAmelCase_			:		bool = False ,  lowerCAmelCase_			:		bool = False ,  lowerCAmelCase_			:		bool = False ,  lowerCAmelCase_			:		bool = False ,  lowerCAmelCase_			:		bool = False ,  lowerCAmelCase_			:		bool = True ,  lowerCAmelCase_			:		Optional[Union[str, TensorType]] = None ,  **lowerCAmelCase_			:		Optional[int] ,  )							->						BatchEncoding:
     if images is None and text is None:
        raise ValueError('You have to specify either images or text.'					)

     # Get only text
     if images is None:
        __lowerCAmelCase							     =     self.tokenizer
        __lowerCAmelCase							     =     self.tokenizer(
            text=lowerCAmelCase_ ,  add_special_tokens=lowerCAmelCase_ ,  padding=lowerCAmelCase_ ,  truncation=lowerCAmelCase_ ,  max_length=lowerCAmelCase_ ,  stride=lowerCAmelCase_ ,  pad_to_multiple_of=lowerCAmelCase_ ,  return_attention_mask=lowerCAmelCase_ ,  return_overflowing_tokens=lowerCAmelCase_ ,  return_special_tokens_mask=lowerCAmelCase_ ,  return_offsets_mapping=lowerCAmelCase_ ,  return_token_type_ids=lowerCAmelCase_ ,  return_length=lowerCAmelCase_ ,  verbose=lowerCAmelCase_ ,  return_tensors=lowerCAmelCase_ ,  **lowerCAmelCase_ ,  )
        return text_encoding

     # add pixel_values
     __lowerCAmelCase							     =     self.image_processor(lowerCAmelCase_ ,  return_tensors=lowerCAmelCase_					)

     if text is not None:
        __lowerCAmelCase							     =     self.tokenizer(
            text=lowerCAmelCase_ ,  add_special_tokens=lowerCAmelCase_ ,  padding=lowerCAmelCase_ ,  truncation=lowerCAmelCase_ ,  max_length=lowerCAmelCase_ ,  stride=lowerCAmelCase_ ,  pad_to_multiple_of=lowerCAmelCase_ ,  return_attention_mask=lowerCAmelCase_ ,  return_overflowing_tokens=lowerCAmelCase_ ,  return_special_tokens_mask=lowerCAmelCase_ ,  return_offsets_mapping=lowerCAmelCase_ ,  return_token_type_ids=lowerCAmelCase_ ,  return_length=lowerCAmelCase_ ,  verbose=lowerCAmelCase_ ,  return_tensors=lowerCAmelCase_ ,  **lowerCAmelCase_ ,  )
     else:
        __lowerCAmelCase							     =     None

     if text_encoding is not None:
        encoding_image_processor.update(lowerCAmelCase_					)

     return encoding_image_processor






  def     lowercase		(    self			:		List[Any] ,  *lowerCAmelCase_			:		int ,  **lowerCAmelCase_			:		Tuple					)							->						Optional[int]:
     return self.tokenizer.batch_decode(*lowerCAmelCase_ ,  **lowerCAmelCase_					)






  def     lowercase		(    self			:		Any ,  *lowerCAmelCase_			:		Optional[Any] ,  **lowerCAmelCase_			:		List[Any]					)							->						Any:
     return self.tokenizer.decode(*lowerCAmelCase_ ,  **lowerCAmelCase_					)






  @property
  def     lowercase		(    self			:		List[Any]					)							->						Any:
     __lowerCAmelCase							     =     self.tokenizer.model_input_names
     __lowerCAmelCase							     =     self.image_processor.model_input_names
     return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names					)					)








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   a_   (			lowerCAmelCase_				:      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(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     )

   __lowerCAmelCase							     =     torch.tensor(
       lowerCAmelCase_,     dtype=torch.intaa,     device=protein['aatype'].device,     )
   __lowerCAmelCase							     =     torch.tensor(
       lowerCAmelCase_,     dtype=torch.intaa,     device=protein['aatype'].device,     )
   __lowerCAmelCase							     =     torch.tensor(
       lowerCAmelCase_,     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   a_   (			lowerCAmelCase_				:      Dict[str, torch.Tensor]     ):
   __lowerCAmelCase							     =     tree_map(lambda lowerCAmelCase_     : torch.tensor(lowerCAmelCase_,     device=batch['aatype'].device     ),     lowerCAmelCase_,     np.ndarray     )
   __lowerCAmelCase							     =     tensor_tree_map(lambda lowerCAmelCase_     : np.array(lowerCAmelCase_     ),     make_atomaa_masks(lowerCAmelCase_     )     )
   return out

