



import os
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils import AddedToken
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
    from .tokenization_xlnet import XLNetTokenizer
else:
    __UpperCAmelCase	       =	None


__UpperCAmelCase	       =	logging.get_logger(__name__)

__UpperCAmelCase	       =	{'''vocab_file''': '''spiece.model''', '''tokenizer_file''': '''tokenizer.json'''}

__UpperCAmelCase	       =	{
    '''vocab_file''': {
        '''xlnet-base-cased''': '''https://huggingface.co/xlnet-base-cased/resolve/main/spiece.model''',
        '''xlnet-large-cased''': '''https://huggingface.co/xlnet-large-cased/resolve/main/spiece.model''',
    },
    '''tokenizer_file''': {
        '''xlnet-base-cased''': '''https://huggingface.co/xlnet-base-cased/resolve/main/tokenizer.json''',
        '''xlnet-large-cased''': '''https://huggingface.co/xlnet-large-cased/resolve/main/tokenizer.json''',
    },
}

__UpperCAmelCase	       =	{
    '''xlnet-base-cased''': None,
    '''xlnet-large-cased''': None,
}

__UpperCAmelCase	       =	'''▁'''

# Segments (not really needed)
__UpperCAmelCase	       =	0
__UpperCAmelCase	       =	1
__UpperCAmelCase	       =	2
__UpperCAmelCase	       =	3
__UpperCAmelCase	       =	4



class     lowerCAmelCase_		(  a__							):
       UpperCAmelCase__    : Optional[int]       					=  VOCAB_FILES_NAMES
       UpperCAmelCase__    : int       					=  PRETRAINED_VOCAB_FILES_MAP
       UpperCAmelCase__    : Optional[int]       					=  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       UpperCAmelCase__    : List[str]       					=  "left"
       UpperCAmelCase__    : List[Any]       					=  XLNetTokenizer
       def __init__(      self,      SCREAMING_SNAKE_CASE_=None,      SCREAMING_SNAKE_CASE_=None,      SCREAMING_SNAKE_CASE_=False,      SCREAMING_SNAKE_CASE_=True,      SCREAMING_SNAKE_CASE_=False,      SCREAMING_SNAKE_CASE_="<s>",      SCREAMING_SNAKE_CASE_="</s>",      SCREAMING_SNAKE_CASE_="<unk>",      SCREAMING_SNAKE_CASE_="<sep>",      SCREAMING_SNAKE_CASE_="<pad>",      SCREAMING_SNAKE_CASE_="<cls>",      SCREAMING_SNAKE_CASE_="<mask>",      SCREAMING_SNAKE_CASE_=["<eop>", "<eod>"],      **SCREAMING_SNAKE_CASE_,      )					->		Dict:
          # Mask token behave like a normal word, i.e. include the space before it
          UpperCamelCase   :  List[Any]						     =     AddedToken(SCREAMING_SNAKE_CASE_,      lstrip=SCREAMING_SNAKE_CASE_,      rstrip=SCREAMING_SNAKE_CASE_	) if isinstance(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	) else mask_token

          super().__init__(
              vocab_file=SCREAMING_SNAKE_CASE_,      tokenizer_file=SCREAMING_SNAKE_CASE_,      do_lower_case=SCREAMING_SNAKE_CASE_,      remove_space=SCREAMING_SNAKE_CASE_,      keep_accents=SCREAMING_SNAKE_CASE_,      bos_token=SCREAMING_SNAKE_CASE_,      eos_token=SCREAMING_SNAKE_CASE_,      unk_token=SCREAMING_SNAKE_CASE_,      sep_token=SCREAMING_SNAKE_CASE_,      pad_token=SCREAMING_SNAKE_CASE_,      cls_token=SCREAMING_SNAKE_CASE_,      mask_token=SCREAMING_SNAKE_CASE_,      additional_special_tokens=SCREAMING_SNAKE_CASE_,      **SCREAMING_SNAKE_CASE_,      )

          UpperCamelCase   :  int						     =     3
          UpperCamelCase   :  Any						     =     do_lower_case
          UpperCamelCase   :  Tuple						     =     remove_space
          UpperCamelCase   :  Optional[int]						     =     keep_accents
          UpperCamelCase   :  List[str]						     =     vocab_file
          UpperCamelCase   :  Union[str, Any]						     =     False if not self.vocab_file else True
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_ = None	)					->		List[int]:
          UpperCamelCase   :  Optional[int]						     =     [self.sep_token_id]
          UpperCamelCase   :  str						     =     [self.cls_token_id]
          if token_ids_a is None:
             return token_ids_a + sep + cls
          return token_ids_a + sep + token_ids_a + sep + cls
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_ = None	)					->		List[int]:
          UpperCamelCase   :  List[Any]						     =     [self.sep_token_id]
          UpperCamelCase   :  Tuple						     =     [2]

          if token_ids_a is None:
             return len(token_ids_a + sep	) * [0] + cls_segment_id
          return len(token_ids_a + sep	) * [0] + len(token_ids_a + sep	) * [1] + cls_segment_id






       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_ = None	)					->		Tuple[str]:
          if not self.can_save_slow_tokenizer:
             raise ValueError(
                 'Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '
                 'tokenizer.'	)

          if not os.path.isdir(SCREAMING_SNAKE_CASE_	):
             logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""	)
             return
          UpperCamelCase   :  List[str]						     =     os.path.join(
              SCREAMING_SNAKE_CASE_,      (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']	)

          if os.path.abspath(self.vocab_file	) != os.path.abspath(SCREAMING_SNAKE_CASE_	):
             copyfile(self.vocab_file,      SCREAMING_SNAKE_CASE_	)

          return (out_vocab_file,)





import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers.models.esm.modeling_esmfold import EsmForProteinFolding



class     lowerCAmelCase_		:
       def __init__(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_=13,      SCREAMING_SNAKE_CASE_=7,      SCREAMING_SNAKE_CASE_=False,      SCREAMING_SNAKE_CASE_=True,      SCREAMING_SNAKE_CASE_=False,      SCREAMING_SNAKE_CASE_=False,      SCREAMING_SNAKE_CASE_=19,      SCREAMING_SNAKE_CASE_=32,      SCREAMING_SNAKE_CASE_=5,      SCREAMING_SNAKE_CASE_=4,      SCREAMING_SNAKE_CASE_=37,      SCREAMING_SNAKE_CASE_="gelu",      SCREAMING_SNAKE_CASE_=0.1,      SCREAMING_SNAKE_CASE_=0.1,      SCREAMING_SNAKE_CASE_=512,      SCREAMING_SNAKE_CASE_=16,      SCREAMING_SNAKE_CASE_=2,      SCREAMING_SNAKE_CASE_=0.02,      SCREAMING_SNAKE_CASE_=3,      SCREAMING_SNAKE_CASE_=4,      SCREAMING_SNAKE_CASE_=None,      )					->		Optional[int]:
          UpperCamelCase   :  Any						     =     parent
          UpperCamelCase   :  Optional[Any]						     =     batch_size
          UpperCamelCase   :  Optional[Any]						     =     seq_length
          UpperCamelCase   :  Tuple						     =     is_training
          UpperCamelCase   :  List[str]						     =     use_input_mask
          UpperCamelCase   :  Optional[int]						     =     use_token_type_ids
          UpperCamelCase   :  Any						     =     use_labels
          UpperCamelCase   :  Union[str, Any]						     =     vocab_size
          UpperCamelCase   :  int						     =     hidden_size
          UpperCamelCase   :  List[Any]						     =     num_hidden_layers
          UpperCamelCase   :  Dict						     =     num_attention_heads
          UpperCamelCase   :  List[Any]						     =     intermediate_size
          UpperCamelCase   :  str						     =     hidden_act
          UpperCamelCase   :  List[Any]						     =     hidden_dropout_prob
          UpperCamelCase   :  List[str]						     =     attention_probs_dropout_prob
          UpperCamelCase   :  List[str]						     =     max_position_embeddings
          UpperCamelCase   :  Union[str, Any]						     =     type_vocab_size
          UpperCamelCase   :  str						     =     type_sequence_label_size
          UpperCamelCase   :  List[str]						     =     initializer_range
          UpperCamelCase   :  List[Any]						     =     num_labels
          UpperCamelCase   :  Any						     =     num_choices
          UpperCamelCase   :  Tuple						     =     scope
       def  snake_case_	(      self	)					->		Optional[int]:
          UpperCamelCase   :  str						     =     ids_tensor([self.batch_size, self.seq_length],      self.vocab_size	)

          UpperCamelCase   :  Optional[Any]						     =     None
          if self.use_input_mask:
             UpperCamelCase   :  Dict						     =     random_attention_mask([self.batch_size, self.seq_length]	)

          UpperCamelCase   :  Union[str, Any]						     =     None
          UpperCamelCase   :  Optional[int]						     =     None
          UpperCamelCase   :  Optional[int]						     =     None
          if self.use_labels:
             UpperCamelCase   :  int						     =     ids_tensor([self.batch_size],      self.type_sequence_label_size	)
             UpperCamelCase   :  Optional[Any]						     =     ids_tensor([self.batch_size, self.seq_length],      self.num_labels	)
             UpperCamelCase   :  Tuple						     =     ids_tensor([self.batch_size],      self.num_choices	)

          UpperCamelCase   :  Union[str, Any]						     =     self.get_config()

          return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels
       def  snake_case_	(      self	)					->		Optional[int]:
          UpperCamelCase   :  List[str]						     =     EsmConfig(
              vocab_size=33,      hidden_size=self.hidden_size,      pad_token_id=1,      num_hidden_layers=self.num_hidden_layers,      num_attention_heads=self.num_attention_heads,      intermediate_size=self.intermediate_size,      hidden_act=self.hidden_act,      hidden_dropout_prob=self.hidden_dropout_prob,      attention_probs_dropout_prob=self.attention_probs_dropout_prob,      max_position_embeddings=self.max_position_embeddings,      type_vocab_size=self.type_vocab_size,      initializer_range=self.initializer_range,      is_folding_model=SCREAMING_SNAKE_CASE_,      esmfold_config={'trunk': {'num_blocks': 2}, 'fp16_esm': False},      )
          return config
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		Tuple:
          UpperCamelCase   :  Union[str, Any]						     =     EsmForProteinFolding(config=SCREAMING_SNAKE_CASE_	).float()
          model.to(SCREAMING_SNAKE_CASE_	)
          model.eval()
          UpperCamelCase   :  int						     =     model(SCREAMING_SNAKE_CASE_,      attention_mask=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  List[Any]						     =     model(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  List[Any]						     =     model(SCREAMING_SNAKE_CASE_	)

          self.parent.assertEqual(result.positions.shape,      (8, self.batch_size, self.seq_length, 14, 3)	)
          self.parent.assertEqual(result.angles.shape,      (8, self.batch_size, self.seq_length, 7, 2)	)






       def  snake_case_	(      self	)					->		Optional[int]:
          UpperCamelCase   :  Union[str, Any]						     =     self.prepare_config_and_inputs()
          (
              (
              UpperCamelCase
          )     ,					(
              UpperCamelCase
          )     ,					(
              UpperCamelCase
          )     ,					(
              UpperCamelCase
          )     ,					(
              UpperCamelCase
          )     ,					(
              UpperCamelCase
          )     ,					
          )   :  Tuple						     =     config_and_inputs
          UpperCamelCase   :  Optional[Any]						     =     {'input_ids': input_ids, 'attention_mask': input_mask}
          return config, inputs_dict






@require_torch
class     lowerCAmelCase_		(  a__	,   a__	,   unittest.TestCase							):
       UpperCAmelCase__    : Dict       					=  False

       UpperCAmelCase__    : Optional[int]       					=  (EsmForProteinFolding,) if is_torch_available() else ()
       UpperCAmelCase__    : int       					=  ()
       UpperCAmelCase__    : List[str]       					=  {} if is_torch_available() else {}
       UpperCAmelCase__    : Optional[int]       					=  False
       def  snake_case_	(      self	)					->		Dict:
          UpperCamelCase   :  Tuple						     =     EsmFoldModelTester(self	)
          UpperCamelCase   :  List[str]						     =     ConfigTester(self,      config_class=SCREAMING_SNAKE_CASE_,      hidden_size=37	)
       def  snake_case_	(      self	)					->		int:
          self.config_tester.run_common_tests()
       def  snake_case_	(      self	)					->		Union[str, Any]:
          UpperCamelCase   :  int						     =     self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_	)
       @unittest.skip('Does not support attention outputs'	)
       def  snake_case_	(      self	)					->		Tuple:
          pass
       @unittest.skip
       def  snake_case_	(      self	)					->		List[Any]:
          pass
       @unittest.skip('Esm does not support embedding resizing'	)
       def  snake_case_	(      self	)					->		Any:
          pass
       @unittest.skip('Esm does not support embedding resizing'	)
       def  snake_case_	(      self	)					->		Optional[Any]:
          pass
       @unittest.skip('ESMFold does not support passing input embeds!'	)
       def  snake_case_	(      self	)					->		Optional[Any]:
          pass
       @unittest.skip('ESMFold does not support head pruning.'	)
       def  snake_case_	(      self	)					->		Any:
          pass
       @unittest.skip('ESMFold does not support head pruning.'	)
       def  snake_case_	(      self	)					->		int:
          pass
       @unittest.skip('ESMFold does not support head pruning.'	)
       def  snake_case_	(      self	)					->		Dict:
          pass
       @unittest.skip('ESMFold does not support head pruning.'	)
       def  snake_case_	(      self	)					->		Union[str, Any]:
          pass
       @unittest.skip('ESMFold does not support head pruning.'	)
       def  snake_case_	(      self	)					->		Any:
          pass
       @unittest.skip('ESMFold does not output hidden states in the normal way.'	)
       def  snake_case_	(      self	)					->		str:
          pass
       @unittest.skip('ESMfold does not output hidden states in the normal way.'	)
       def  snake_case_	(      self	)					->		List[str]:
          pass
       @unittest.skip('ESMFold only has one output format.'	)
       def  snake_case_	(      self	)					->		int:
          pass
       @unittest.skip('This test doesn\'t work for ESMFold and doesn\'t test core functionality'	)
       def  snake_case_	(      self	)					->		Any:
          pass
       @unittest.skip('ESMFold does not support input chunking.'	)
       def  snake_case_	(      self	)					->		Any:
          pass
       @unittest.skip('ESMFold doesn\'t respect you and it certainly doesn\'t respect your initialization arguments.'	)
       def  snake_case_	(      self	)					->		Tuple:
          pass
       @unittest.skip('ESMFold doesn\'t support torchscript compilation.'	)
       def  snake_case_	(      self	)					->		Any:
          pass
       @unittest.skip('ESMFold doesn\'t support torchscript compilation.'	)
       def  snake_case_	(      self	)					->		str:
          pass
       @unittest.skip('ESMFold doesn\'t support torchscript compilation.'	)
       def  snake_case_	(      self	)					->		List[Any]:
          pass
       @unittest.skip('ESMFold doesn\'t support data parallel.'	)
       def  snake_case_	(      self	)					->		List[str]:
          pass






       @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'	)
       def  snake_case_	(      self	)					->		Optional[Any]:
          pass






@require_torch
class     lowerCAmelCase_		(  a__							):
       @slow
       def  snake_case_	(      self	)					->		str:
          UpperCamelCase   :  Union[str, Any]						     =     EsmForProteinFolding.from_pretrained('facebook/esmfold_v1'	).float()
          model.eval()
          UpperCamelCase   :  Tuple						     =     torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]	)
          UpperCamelCase   :  List[str]						     =     model(SCREAMING_SNAKE_CASE_	)['positions']
          UpperCamelCase   :  int						     =     torch.tensor([2.58_28, 0.79_93, -10.93_34],      dtype=torch.floataa	)
          self.assertTrue(torch.allclose(position_outputs[0, 0, 0, 0],      SCREAMING_SNAKE_CASE_,      atol=1e-4	)	)



