





'''simple docstring'''

import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers.testing_utils import require_vision
from transformers.utils import is_vision_available


if is_vision_available():
    from PIL import Image

    from transformers import (
        AutoProcessor,
        BertTokenizerFast,
        BlipImageProcessor,
        GPTaTokenizer,
        InstructBlipProcessor,
        PreTrainedTokenizerFast,
    )







@require_vision
class __a			( unittest.TestCase      ):





   def   UpperCAmelCase__  (       self					:      int     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							tempfile.mkdtemp()

      __SCREAMING_SNAKE_CASE   				=							BlipImageProcessor()
      __SCREAMING_SNAKE_CASE   				=							GPTaTokenizer.from_pretrained("""hf-internal-testing/tiny-random-GPT2Model"""     )
      __SCREAMING_SNAKE_CASE   				=							BertTokenizerFast.from_pretrained("""hf-internal-testing/tiny-random-bert"""     )

      __SCREAMING_SNAKE_CASE   				=							InstructBlipProcessor(lowerCamelCase					,lowerCamelCase					,lowerCamelCase     )

      processor.save_pretrained(self.tmpdirname     )





   def   UpperCAmelCase__  (       self					:      Optional[int]					,**lowerCamelCase					:      Any     ):

      '''simple docstring'''

      return AutoProcessor.from_pretrained(self.tmpdirname					,**lowerCamelCase     ).tokenizer





   def   UpperCAmelCase__  (       self					:      Dict					,**lowerCamelCase					:      Optional[Any]     ):

      '''simple docstring'''

      return AutoProcessor.from_pretrained(self.tmpdirname					,**lowerCamelCase     ).image_processor





   def   UpperCAmelCase__  (       self					:      Optional[int]					,**lowerCamelCase					:      Dict     ):

      '''simple docstring'''

      return AutoProcessor.from_pretrained(self.tmpdirname					,**lowerCamelCase     ).qformer_tokenizer





   def   UpperCAmelCase__  (       self					:      List[str]     ):

      '''simple docstring'''

      shutil.rmtree(self.tmpdirname     )





   def   UpperCAmelCase__  (       self					:      Optional[int]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							[np.random.randint(255					,size=(3, 30, 400)					,dtype=np.uinta     )]

      __SCREAMING_SNAKE_CASE   				=							[Image.fromarray(np.moveaxis(lowerCamelCase					,0					,-1     )     ) for x in image_inputs]

      return image_inputs





   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							InstructBlipProcessor(
          tokenizer=self.get_tokenizer()					,image_processor=self.get_image_processor()					,qformer_tokenizer=self.get_qformer_tokenizer()					,)
      processor.save_pretrained(self.tmpdirname     )

      __SCREAMING_SNAKE_CASE   				=							self.get_tokenizer(bos_token="""(BOS)"""					,eos_token="""(EOS)"""     )
      __SCREAMING_SNAKE_CASE   				=							self.get_image_processor(do_normalize=lowerCamelCase					,padding_value=1.0     )

      __SCREAMING_SNAKE_CASE   				=							InstructBlipProcessor.from_pretrained(
          self.tmpdirname					,bos_token="""(BOS)"""					,eos_token="""(EOS)"""					,do_normalize=lowerCamelCase					,padding_value=1.0     )

      self.assertEqual(processor.tokenizer.get_vocab()					,tokenizer_add_kwargs.get_vocab()     )
      self.assertIsInstance(processor.tokenizer					,lowerCamelCase     )

      self.assertEqual(processor.image_processor.to_json_string()					,image_processor_add_kwargs.to_json_string()     )
      self.assertIsInstance(processor.image_processor					,lowerCamelCase     )
      self.assertIsInstance(processor.qformer_tokenizer					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.get_image_processor()
      __SCREAMING_SNAKE_CASE   				=							self.get_tokenizer()
      __SCREAMING_SNAKE_CASE   				=							self.get_qformer_tokenizer()

      __SCREAMING_SNAKE_CASE   				=							InstructBlipProcessor(
          tokenizer=lowerCamelCase					,image_processor=lowerCamelCase					,qformer_tokenizer=lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							self.prepare_image_inputs()

      __SCREAMING_SNAKE_CASE   				=							image_processor(lowerCamelCase					,return_tensors="""np"""     )
      __SCREAMING_SNAKE_CASE   				=							processor(images=lowerCamelCase					,return_tensors="""np"""     )

      for key in input_feat_extract.keys():
         self.assertAlmostEqual(input_feat_extract[key].sum()					,input_processor[key].sum()					,delta=1E-2     )





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.get_image_processor()
      __SCREAMING_SNAKE_CASE   				=							self.get_tokenizer()
      __SCREAMING_SNAKE_CASE   				=							self.get_qformer_tokenizer()

      __SCREAMING_SNAKE_CASE   				=							InstructBlipProcessor(
          tokenizer=lowerCamelCase					,image_processor=lowerCamelCase					,qformer_tokenizer=lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							"""lower newer"""

      __SCREAMING_SNAKE_CASE   				=							processor(text=lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							tokenizer(lowerCamelCase					,return_token_type_ids=lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							qformer_tokenizer(lowerCamelCase					,return_token_type_ids=lowerCamelCase     )

      for key in encoded_tokens.keys():
         self.assertListEqual(encoded_tokens[key]					,encoded_processor[key]     )

      for key in encoded_tokens_qformer.keys():
         self.assertListEqual(encoded_tokens_qformer[key]					,encoded_processor["""qformer_""" + key]     )





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.get_image_processor()
      __SCREAMING_SNAKE_CASE   				=							self.get_tokenizer()
      __SCREAMING_SNAKE_CASE   				=							self.get_qformer_tokenizer()

      __SCREAMING_SNAKE_CASE   				=							InstructBlipProcessor(
          tokenizer=lowerCamelCase					,image_processor=lowerCamelCase					,qformer_tokenizer=lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							"""lower newer"""
      __SCREAMING_SNAKE_CASE   				=							self.prepare_image_inputs()

      __SCREAMING_SNAKE_CASE   				=							processor(text=lowerCamelCase					,images=lowerCamelCase     )

      self.assertListEqual(
          list(inputs.keys()     )					,["""input_ids""", """attention_mask""", """qformer_input_ids""", """qformer_attention_mask""", """pixel_values"""]					,)

      # test if it raises when no input is passed
      with pytest.raises(lowerCamelCase     ):
         processor()





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.get_image_processor()
      __SCREAMING_SNAKE_CASE   				=							self.get_tokenizer()
      __SCREAMING_SNAKE_CASE   				=							self.get_qformer_tokenizer()

      __SCREAMING_SNAKE_CASE   				=							InstructBlipProcessor(
          tokenizer=lowerCamelCase					,image_processor=lowerCamelCase					,qformer_tokenizer=lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

      __SCREAMING_SNAKE_CASE   				=							processor.batch_decode(lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							tokenizer.batch_decode(lowerCamelCase     )

      self.assertListEqual(lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      int     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.get_image_processor()
      __SCREAMING_SNAKE_CASE   				=							self.get_tokenizer()
      __SCREAMING_SNAKE_CASE   				=							self.get_qformer_tokenizer()

      __SCREAMING_SNAKE_CASE   				=							InstructBlipProcessor(
          tokenizer=lowerCamelCase					,image_processor=lowerCamelCase					,qformer_tokenizer=lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							"""lower newer"""
      __SCREAMING_SNAKE_CASE   				=							self.prepare_image_inputs()

      __SCREAMING_SNAKE_CASE   				=							processor(text=lowerCamelCase					,images=lowerCamelCase     )

      self.assertListEqual(
          list(inputs.keys()     )					,["""input_ids""", """attention_mask""", """qformer_input_ids""", """qformer_attention_mask""", """pixel_values"""]					,)












'''simple docstring'''

from dataclasses import asdict, dataclass
from typing import Optional

from ...configuration_utils import PretrainedConfig
from ...utils import logging


a   	=    logging.get_logger(__name__)

# TODO Update this
a   	=    {
    "facebook/esm-1b": "https://huggingface.co/facebook/esm-1b/resolve/main/config.json",
    # See all ESM models at https://huggingface.co/models?filter=esm
}







class __a			( _snake_case      ):
   __UpperCamelCase :			str						   =						'esm'





   def __init__(       self					:      Tuple					,lowerCamelCase					:      List[Any]=None					,lowerCamelCase					:      str=None					,lowerCamelCase					:      Any=None					,lowerCamelCase					:      Union[str, Any]=768					,lowerCamelCase					:      Tuple=12					,lowerCamelCase					:      int=12					,lowerCamelCase					:      Optional[int]=3072					,lowerCamelCase					:      List[Any]=0.1					,lowerCamelCase					:      Optional[int]=0.1					,lowerCamelCase					:      Any=1026					,lowerCamelCase					:      str=0.02					,lowerCamelCase					:      int=1E-1_2					,lowerCamelCase					:      Union[str, Any]="absolute"					,lowerCamelCase					:      Optional[Any]=True					,lowerCamelCase					:      str=None					,lowerCamelCase					:      Optional[int]=False					,lowerCamelCase					:      int=False					,lowerCamelCase					:      Union[str, Any]=None					,lowerCamelCase					:      Any=None					,**lowerCamelCase					:      Any					,):

      '''simple docstring'''

      super().__init__(pad_token_id=lowerCamelCase					,mask_token_id=lowerCamelCase					,**lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							vocab_size
      __SCREAMING_SNAKE_CASE   				=							hidden_size
      __SCREAMING_SNAKE_CASE   				=							num_hidden_layers
      __SCREAMING_SNAKE_CASE   				=							num_attention_heads
      __SCREAMING_SNAKE_CASE   				=							intermediate_size
      __SCREAMING_SNAKE_CASE   				=							hidden_dropout_prob
      __SCREAMING_SNAKE_CASE   				=							attention_probs_dropout_prob
      __SCREAMING_SNAKE_CASE   				=							max_position_embeddings
      __SCREAMING_SNAKE_CASE   				=							initializer_range
      __SCREAMING_SNAKE_CASE   				=							layer_norm_eps
      __SCREAMING_SNAKE_CASE   				=							position_embedding_type
      __SCREAMING_SNAKE_CASE   				=							use_cache
      __SCREAMING_SNAKE_CASE   				=							emb_layer_norm_before
      __SCREAMING_SNAKE_CASE   				=							token_dropout
      __SCREAMING_SNAKE_CASE   				=							is_folding_model
      if is_folding_model:
         if esmfold_config is None:
            logger.info("""No esmfold_config supplied for folding model, using default values."""     )
            __SCREAMING_SNAKE_CASE   				=							EsmFoldConfig()
         elif isinstance(lowerCamelCase					,lowerCamelCase     ):
            __SCREAMING_SNAKE_CASE   				=							EsmFoldConfig(**lowerCamelCase     )
         __SCREAMING_SNAKE_CASE   				=							esmfold_config
         if vocab_list is None:
            logger.warning("""No vocab_list supplied for folding model, assuming the ESM-2 vocabulary!"""     )
            __SCREAMING_SNAKE_CASE   				=							get_default_vocab_list()
         else:
            __SCREAMING_SNAKE_CASE   				=							vocab_list
      else:
         __SCREAMING_SNAKE_CASE   				=							None
         __SCREAMING_SNAKE_CASE   				=							None
      if self.esmfold_config is not None and getattr(self.esmfold_config					,"""use_esm_attn_map"""					,lowerCamelCase     ):
         raise ValueError("""The HuggingFace port of ESMFold does not support use_esm_attn_map at this time!"""     )





   def   UpperCAmelCase__  (       self					:      List[str]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							super().to_dict()
      if isinstance(self.esmfold_config					,lowerCamelCase     ):
         __SCREAMING_SNAKE_CASE   				=							self.esmfold_config.to_dict()
      return output







@dataclass
class __a			:
   __UpperCamelCase :			str						   =						None
   __UpperCamelCase :			bool						   =						True
   __UpperCamelCase :			bool						   =						False
   __UpperCamelCase :			bool						   =						False
   __UpperCamelCase :			bool						   =						False
   __UpperCamelCase :			float						   =						0

   __UpperCamelCase :			bool						   =						True
   __UpperCamelCase :			bool						   =						False

   __UpperCamelCase :			int						   =						128
   __UpperCamelCase :			"TrunkConfig"						   =						None





   def   UpperCAmelCase__  (       self					:      List[str]     ):

      '''simple docstring'''

      if self.trunk is None:
         __SCREAMING_SNAKE_CASE   				=							TrunkConfig()
      elif isinstance(self.trunk					,lowerCamelCase     ):
         __SCREAMING_SNAKE_CASE   				=							TrunkConfig(**self.trunk     )





   def   UpperCAmelCase__  (       self					:      Optional[int]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							asdict(self     )
      __SCREAMING_SNAKE_CASE   				=							self.trunk.to_dict()
      return output







@dataclass
class __a			:
   __UpperCamelCase :			int						   =						48
   __UpperCamelCase :			int						   =						1024
   __UpperCamelCase :			int						   =						128
   __UpperCamelCase :			int						   =						32
   __UpperCamelCase :			int						   =						32
   __UpperCamelCase :			int						   =						32
   __UpperCamelCase :			float						   =						0
   __UpperCamelCase :			float						   =						0
   __UpperCamelCase :			bool						   =						False
   __UpperCamelCase :			int						   =						4
   __UpperCamelCase :			Optional[int]						   =						128
   __UpperCamelCase :			"StructureModuleConfig"						   =						None





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

      if self.structure_module is None:
         __SCREAMING_SNAKE_CASE   				=							StructureModuleConfig()
      elif isinstance(self.structure_module					,lowerCamelCase     ):
         __SCREAMING_SNAKE_CASE   				=							StructureModuleConfig(**self.structure_module     )

      if self.max_recycles <= 0:
         raise ValueError(f"""`max_recycles` should be positive, got {self.max_recycles}."""     )
      if self.sequence_state_dim % self.sequence_state_dim != 0:
         raise ValueError(
             """`sequence_state_dim` should be a round multiple of `sequence_state_dim`, got"""
             f""" {self.sequence_state_dim} and {self.sequence_state_dim}."""     )
      if self.pairwise_state_dim % self.pairwise_state_dim != 0:
         raise ValueError(
             """`pairwise_state_dim` should be a round multiple of `pairwise_state_dim`, got"""
             f""" {self.pairwise_state_dim} and {self.pairwise_state_dim}."""     )

      __SCREAMING_SNAKE_CASE   				=							self.sequence_state_dim // self.sequence_head_width
      __SCREAMING_SNAKE_CASE   				=							self.pairwise_state_dim // self.pairwise_head_width

      if self.sequence_state_dim != sequence_num_heads * self.sequence_head_width:
         raise ValueError(
             """`sequence_state_dim` should be equal to `sequence_num_heads * sequence_head_width, got"""
             f""" {self.sequence_state_dim} != {sequence_num_heads} * {self.sequence_head_width}."""     )
      if self.pairwise_state_dim != pairwise_num_heads * self.pairwise_head_width:
         raise ValueError(
             """`pairwise_state_dim` should be equal to `pairwise_num_heads * pairwise_head_width, got"""
             f""" {self.pairwise_state_dim} != {pairwise_num_heads} * {self.pairwise_head_width}."""     )
      if self.pairwise_state_dim % 2 != 0:
         raise ValueError(f"""`pairwise_state_dim` should be even, got {self.pairwise_state_dim}."""     )

      if self.dropout >= 0.4:
         raise ValueError(f"""`dropout` should not be greater than 0.4, got {self.dropout}."""     )





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							asdict(self     )
      __SCREAMING_SNAKE_CASE   				=							self.structure_module.to_dict()
      return output







@dataclass
class __a			:
   __UpperCamelCase :			int						   =						384
   __UpperCamelCase :			int						   =						128
   __UpperCamelCase :			int						   =						16
   __UpperCamelCase :			int						   =						128
   __UpperCamelCase :			int						   =						12
   __UpperCamelCase :			int						   =						4
   __UpperCamelCase :			int						   =						8
   __UpperCamelCase :			float						   =						0.1
   __UpperCamelCase :			int						   =						8
   __UpperCamelCase :			int						   =						1
   __UpperCamelCase :			int						   =						2
   __UpperCamelCase :			int						   =						7
   __UpperCamelCase :			int						   =						10
   __UpperCamelCase :			float						   =						1E-8
   __UpperCamelCase :			float						   =						1E5





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

      return asdict(self     )





def     __magic_name__							(				)    ->       Dict:

   '''simple docstring'''







   return (
       "<cls>",
       "<pad>",
       "<eos>",
       "<unk>",
       "L",
       "A",
       "G",
       "V",
       "S",
       "E",
       "R",
       "T",
       "I",
       "D",
       "P",
       "K",
       "Q",
       "N",
       "F",
       "Y",
       "M",
       "H",
       "W",
       "C",
       "X",
       "B",
       "U",
       "Z",
       "O",
       ".",
       "-",
       "<null_1>",
       "<mask>",
   )





