






"""simple docstring"""






import unittest

from transformers import BigBirdTokenizer, BigBirdTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


UpperCAmelCase_   : str   			= """▁"""

UpperCAmelCase_   : List[Any]   			= get_tests_dir("""fixtures/test_sentencepiece.model""")




@require_sentencepiece
@require_tokenizers
class 							lowerCAmelCase__				(			UpperCAmelCase__				,		unittest.TestCase ):






      '''simple docstring'''

      __UpperCamelCase	 =  BigBirdTokenizer
      __UpperCamelCase	 =  BigBirdTokenizerFast
      __UpperCamelCase	 =  True
      __UpperCamelCase	 =  True
      def _SCREAMING_SNAKE_CASE (						self     :  Tuple):




          '''simple docstring'''


          super().setUp()

          SCREAMING_SNAKE_CASE_      :  Any    						=		self.tokenizer_class(lowercase_						,	keep_accents=lowercase_)
          tokenizer.save_pretrained(self.tmpdirname)
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		'''<s>'''
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		1

          self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowercase_)						,	lowercase_)
          self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowercase_)						,	lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		list(self.get_tokenizer().get_vocab().keys())

          self.assertEqual(vocab_keys[0]						,	'''<unk>''')
          self.assertEqual(vocab_keys[1]						,	'''<s>''')
          self.assertEqual(vocab_keys[-1]						,	'''[MASK]''')
          self.assertEqual(len(lowercase_)						,	1004)
      def _SCREAMING_SNAKE_CASE (						self     :  Tuple):




          '''simple docstring'''


          self.assertEqual(self.get_tokenizer().vocab_size						,	1000)
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]):




          '''simple docstring'''


          if not self.test_rust_tokenizer:
              return

          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		self.get_tokenizer()
          SCREAMING_SNAKE_CASE_      :  int    						=		self.get_rust_tokenizer()

          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		'''I was born in 92000, and this is falsé.'''

          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		tokenizer.tokenize(lowercase_)
          SCREAMING_SNAKE_CASE_      :  str    						=		rust_tokenizer.tokenize(lowercase_)
          self.assertListEqual(lowercase_						,	lowercase_)

          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		tokenizer.encode(lowercase_						,	add_special_tokens=lowercase_)
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		rust_tokenizer.encode(lowercase_						,	add_special_tokens=lowercase_)
          self.assertListEqual(lowercase_						,	lowercase_)

          SCREAMING_SNAKE_CASE_      :  List[str]    						=		self.get_rust_tokenizer()
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		tokenizer.encode(lowercase_)
          SCREAMING_SNAKE_CASE_      :  str    						=		rust_tokenizer.encode(lowercase_)
          self.assertListEqual(lowercase_						,	lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Any    						=		BigBirdTokenizer(lowercase_						,	keep_accents=lowercase_)

          SCREAMING_SNAKE_CASE_      :  Tuple    						=		tokenizer.tokenize('''This is a test''')
          self.assertListEqual(lowercase_						,	['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est'''])

          self.assertListEqual(
              tokenizer.convert_tokens_to_ids(lowercase_)						,	[285, 46, 10, 170, 382]						,	)

          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		tokenizer.tokenize('''I was born in 92000, and this is falsé.''')
          self.assertListEqual(
              lowercase_						,	[
                  SPIECE_UNDERLINE + '''I''',
                  SPIECE_UNDERLINE + '''was''',
                  SPIECE_UNDERLINE + '''b''',
                  '''or''',
                  '''n''',
                  SPIECE_UNDERLINE + '''in''',
                  SPIECE_UNDERLINE + '''''',
                  '''9''',
                  '''2''',
                  '''0''',
                  '''0''',
                  '''0''',
                  ''',''',
                  SPIECE_UNDERLINE + '''and''',
                  SPIECE_UNDERLINE + '''this''',
                  SPIECE_UNDERLINE + '''is''',
                  SPIECE_UNDERLINE + '''f''',
                  '''al''',
                  '''s''',
                  '''é''',
                  '''.''',
              ]						,	)
          SCREAMING_SNAKE_CASE_      :  Dict    						=		tokenizer.convert_tokens_to_ids(lowercase_)
          self.assertListEqual(
              lowercase_						,	[8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]						,	)

          SCREAMING_SNAKE_CASE_      :  Dict    						=		tokenizer.convert_ids_to_tokens(lowercase_)
          self.assertListEqual(
              lowercase_						,	[
                  SPIECE_UNDERLINE + '''I''',
                  SPIECE_UNDERLINE + '''was''',
                  SPIECE_UNDERLINE + '''b''',
                  '''or''',
                  '''n''',
                  SPIECE_UNDERLINE + '''in''',
                  SPIECE_UNDERLINE + '''''',
                  '''<unk>''',
                  '''2''',
                  '''0''',
                  '''0''',
                  '''0''',
                  ''',''',
                  SPIECE_UNDERLINE + '''and''',
                  SPIECE_UNDERLINE + '''this''',
                  SPIECE_UNDERLINE + '''is''',
                  SPIECE_UNDERLINE + '''f''',
                  '''al''',
                  '''s''',
                  '''<unk>''',
                  '''.''',
              ]						,	)
      @cached_property
      def _SCREAMING_SNAKE_CASE (						self     :  List[Any]):




          '''simple docstring'''


          return BigBirdTokenizer.from_pretrained('''google/bigbird-roberta-base''')
      @slow
      def _SCREAMING_SNAKE_CASE (						self     :  str):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		'''Hello World!'''
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		[65, 18536, 2260, 101, 66]

          self.assertListEqual(lowercase_						,	self.big_tokenizer.encode(lowercase_))
      @slow
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		(
              '''This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) " [ ] ! : - . Also we will'''
              ''' add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth'''
          )
          # fmt: off
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		[65, 871, 419, 358, 946, 991, 2521, 452, 358, 1357, 387, 7751, 3536, 112, 985, 456, 126, 865, 938, 5400, 5734, 458, 1368, 467, 786, 2462, 5246, 1159, 633, 865, 4519, 457, 582, 852, 2557, 427, 916, 508, 405, 34324, 497, 391, 408, 11342, 1244, 385, 100, 938, 985, 456, 574, 362, 12597, 3200, 3129, 1172, 66]  # noqa: E231
          # fmt: on
          self.assertListEqual(lowercase_						,	self.big_tokenizer.encode(lowercase_))
      @require_torch
      @slow
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          import torch

          from transformers import BigBirdConfig, BigBirdModel

          # Build sequence
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		list(self.big_tokenizer.get_vocab().keys())[:10]
          SCREAMING_SNAKE_CASE_      :  str    						=		''' '''.join(lowercase_)
          SCREAMING_SNAKE_CASE_      :  str    						=		self.big_tokenizer.encode_plus(lowercase_						,	return_tensors='''pt'''						,	return_token_type_ids=lowercase_)
          SCREAMING_SNAKE_CASE_      :  int    						=		self.big_tokenizer.batch_encode_plus(
              [sequence + ''' ''' + sequence]						,	return_tensors='''pt'''						,	return_token_type_ids=lowercase_)

          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		BigBirdConfig(attention_type='''original_full''')
          SCREAMING_SNAKE_CASE_      :  int    						=		BigBirdModel(lowercase_)

          assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

          with torch.no_grad():
              model(**lowercase_)
              model(**lowercase_)
      @slow
      def _SCREAMING_SNAKE_CASE (						self     :  Any):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  int    						=		BigBirdTokenizer.from_pretrained('''google/bigbird-roberta-base''')
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		tokenizer.decode(tokenizer('''Paris is the [MASK].''').input_ids)

          self.assertTrue(decoded_text == '''[CLS] Paris is the[MASK].[SEP]''')



      @slow
      def _SCREAMING_SNAKE_CASE (						self     :  int):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Any    						=		{'''input_ids''': [[65, 39286, 458, 36335, 2001, 456, 13073, 13266, 455, 113, 7746, 1741, 11157, 391, 13073, 13266, 455, 113, 3967, 35412, 113, 4936, 109, 3870, 2377, 113, 30084, 45720, 458, 134, 17496, 112, 503, 11672, 113, 118, 112, 5665, 13347, 38687, 112, 1496, 31389, 112, 3268, 47264, 134, 962, 112, 16377, 8035, 23130, 430, 12169, 15518, 28592, 458, 146, 41697, 109, 391, 12169, 15518, 16689, 458, 146, 41358, 109, 452, 726, 4034, 111, 763, 35412, 5082, 388, 1903, 111, 9051, 391, 2870, 48918, 1900, 1123, 550, 998, 112, 9586, 15985, 455, 391, 410, 22955, 37636, 114, 66], [65, 448, 17496, 419, 3663, 385, 763, 113, 27533, 2870, 3283, 13043, 1639, 24713, 523, 656, 24013, 18550, 2521, 517, 27014, 21244, 420, 1212, 1465, 391, 927, 4833, 388, 578, 11786, 114, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [65, 484, 2169, 7687, 21932, 18146, 726, 363, 17032, 3391, 114, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
          # fmt: on

          self.tokenizer_integration_test_util(
              expected_encoding=lowercase_						,	model_name='''google/bigbird-roberta-base'''						,	revision='''215c99f1600e06f83acce68422f2035b2b5c3510'''						,	)










"""simple docstring"""






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

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


UpperCAmelCase_   : Dict   			= logging.get_logger(__name__)

UpperCAmelCase_   : Tuple   			= """▁"""

UpperCAmelCase_   : Optional[Any]   			= {"""vocab_file""": """sentencepiece.bpe.model"""}

UpperCAmelCase_   : str   			= {
    """vocab_file""": {
        """facebook/xglm-564M""": """https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model""",
    }
}

UpperCAmelCase_   : str   			= {
    """facebook/xglm-564M""": 2048,
}




class 							lowerCAmelCase__				(			UpperCAmelCase__ ):






      '''simple docstring'''

      __UpperCamelCase	 =  VOCAB_FILES_NAMES
      __UpperCamelCase	 =  PRETRAINED_VOCAB_FILES_MAP
      __UpperCamelCase	 =  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      __UpperCamelCase	 =  ["input_ids", "attention_mask"]
      def __init__(						self     :  List[Any]						,	lowercase_     :  str						,	lowercase_     :  Tuple="<s>"						,	lowercase_     :  Any="</s>"						,	lowercase_     :  Optional[int]="</s>"						,	lowercase_     :  List[Any]="<s>"						,	lowercase_     :  Union[str, Any]="<unk>"						,	lowercase_     :  Union[str, Any]="<pad>"						,	lowercase_     :  Optional[Dict[str, Any]] = None						,	**lowercase_     :  Tuple						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Any    						=		{} if sp_model_kwargs is None else sp_model_kwargs

          # Compatibility with the original tokenizer
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		7
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		[F'<madeupword{i}>' for i in range(self.num_madeup_words)]

          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		kwargs.get('''additional_special_tokens'''						,	[])
          kwargs["additional_special_tokens"] += [
              word for word in madeup_words if word not in kwargs["additional_special_tokens"]
          ]

          super().__init__(
              bos_token=lowercase_						,	eos_token=lowercase_						,	unk_token=lowercase_						,	sep_token=lowercase_						,	cls_token=lowercase_						,	pad_token=lowercase_						,	sp_model_kwargs=self.sp_model_kwargs						,	**lowercase_						,	)

          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		spm.SentencePieceProcessor(**self.sp_model_kwargs)
          self.sp_model.Load(str(lowercase_))
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		vocab_file

          # Original fairseq vocab and spm vocab must be "aligned":
          # Vocab    |    0    |    1    |   2    |    3    |  4  |  5  |  6  |   7   |   8   |  9
          # -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
          # fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's'   | '▁de' | '-'
          # spm      | '<unk>' | '<s>'   | '</s>' | ','     | '.' | '▁' | 's' | '▁de' | '-'   | '▁a'

          # The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		1

          # Mimic fairseq token-to-id alignment for the first 4 token
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		{'''<s>''': 0, '''<pad>''': 1, '''</s>''': 2, '''<unk>''': 3}

          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		len(self.sp_model)
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		{F'<madeupword{i}>': sp_size + i + self.fairseq_offset for i in range(self.num_madeup_words)}
          self.fairseq_tokens_to_ids.update(lowercase_)

          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		{v: k for k, v in self.fairseq_tokens_to_ids.items()}
      def __getstate__(						self     :  Dict):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Any    						=		self.__dict__.copy()
          SCREAMING_SNAKE_CASE_      :  str    						=		None
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		self.sp_model.serialized_model_proto()
          return state
      def __setstate__(						self     :  Tuple						,	lowercase_     :  str):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  int    						=		d

          # for backward compatibility
          if not hasattr(self						,	'''sp_model_kwargs'''):
              SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		{}

          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		spm.SentencePieceProcessor(**self.sp_model_kwargs)
          self.sp_model.LoadFromSerializedProto(self.sp_model_proto)
      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]						,	lowercase_     :  List[int]						,	lowercase_     :  Optional[List[int]] = None):




          '''simple docstring'''


          if token_ids_a is None:
              return [self.sep_token_id] + token_ids_a
          SCREAMING_SNAKE_CASE_      :  Dict    						=		[self.sep_token_id]
          return sep + token_ids_a + sep + sep + token_ids_a
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]						,	lowercase_     :  List[int]						,	lowercase_     :  Optional[List[int]] = None						,	lowercase_     :  bool = False):




          '''simple docstring'''


          if already_has_special_tokens:
              return super().get_special_tokens_mask(
                  token_ids_a=lowercase_						,	token_ids_a=lowercase_						,	already_has_special_tokens=lowercase_)

          if token_ids_a is None:
              return [1] + ([0] * len(lowercase_))
          return [1] + ([0] * len(lowercase_)) + [1, 1] + ([0] * len(lowercase_))
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[Any]						,	lowercase_     :  List[int]						,	lowercase_     :  Optional[List[int]] = None):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		[self.sep_token_id]

          if token_ids_a is None:
              return len(sep + token_ids_a) * [0]
          return len(sep + token_ids_a + sep + sep + token_ids_a) * [0]
      @property
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[Any]):




          '''simple docstring'''


          return len(self.sp_model) + self.fairseq_offset + self.num_madeup_words
      def _SCREAMING_SNAKE_CASE (						self     :  Any):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		{self.convert_ids_to_tokens(lowercase_): i for i in range(self.vocab_size)}
          vocab.update(self.added_tokens_encoder)
          return vocab
      def _SCREAMING_SNAKE_CASE (						self     :  Dict						,	lowercase_     :  str):




          '''simple docstring'''


          return self.sp_model.encode(lowercase_						,	out_type=lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[Any]						,	lowercase_     :  Union[str, Any]):




          '''simple docstring'''


          if token in self.fairseq_tokens_to_ids:
              return self.fairseq_tokens_to_ids[token]
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		self.sp_model.PieceToId(lowercase_)

          # Need to return unknown token if the SP model returned 0
          return spm_id + self.fairseq_offset if spm_id else self.unk_token_id
      def _SCREAMING_SNAKE_CASE (						self     :  int						,	lowercase_     :  Optional[Any]):




          '''simple docstring'''


          if index in self.fairseq_ids_to_tokens:
              return self.fairseq_ids_to_tokens[index]
          return self.sp_model.IdToPiece(index - self.fairseq_offset)
      def _SCREAMING_SNAKE_CASE (						self     :  int						,	lowercase_     :  Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		''''''.join(lowercase_).replace(lowercase_						,	''' ''').strip()
          return out_string



      def _SCREAMING_SNAKE_CASE (						self     :  str						,	lowercase_     :  str						,	lowercase_     :  Optional[str] = None):




          '''simple docstring'''


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

          if os.path.abspath(self.vocab_file) != os.path.abspath(lowercase_) and os.path.isfile(self.vocab_file):
              copyfile(self.vocab_file						,	lowercase_)
          elif not os.path.isfile(self.vocab_file):
              with open(lowercase_						,	'''wb''') as fi:
                  SCREAMING_SNAKE_CASE_      :  int    						=		self.sp_model.serialized_model_proto()
                  fi.write(lowercase_)

          return (out_vocab_file,)


